#define BLUETOOTH_DEVICE_NAME_LENGTH_MAX 248 /**< This specifies maximum device name length */
#define BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX 50 /**< This specifies maximum length of the passkey */
#define BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX 31 /**< This specifies maximum AD data length */
+#define BLUETOOTH_EXTENDED_ADVERTISING_DATA_LENGTH_MAX 255 /**< This specifies maximum AD data length */
#define BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX 31 /**< This specifies maximum LE Scan response data length */
#define BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX 240 /**< This specifies maximum manufacturer data length */
+#define BLUETOOTH_APPEARANCE_LENGTH 2 /**< This specifies bluetooth device appearance characteristic length */
#define BLUETOOTH_MAX_SERVICES_FOR_DEVICE 40 /**< This specifies maximum number of services
a device can support */
* This is RFCOMM default Channel Value
*/
#define RFCOMM_DEFAULT_PROFILE_CHANNEL 0
+#define RFCOMM_ROBOT_PROFILE_CHANNEL 22
+
+/**
+ * This is L2cap LE Socket Connected event role
+ */
+#define L2CAP_LE_ROLE_SERVER 1
+#define L2CAP_LE_ROLE_CLIENT 2
/**
* This is maximum length for search value string for PBAP Phonebook Search
* Advertising data
*/
typedef struct {
+ /* TODO : Change to BLUETOOTH_EXTENDED_ADVERTISING_DATA_LENGTH_MAX
+ * once LE EXTENDED feature is supported */
guint8 data[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX];
} bluetooth_advertising_data_t;
*/
typedef enum {
BLUETOOTH_ALLOW_SCAN_CONN_ALL = 0x00,
- BLUETOOTH_ALLOW_CONN_ALL_SCAN_WHITE_LIST = 0x01,
- BLUETOOTH_ALLOW_SCAN_ALL_CONN_WHITE_LIST = 0x02,
- BLUETOOTH_ALLOW_SCAN_CONN_WHITE_LIST = 0x03,
+ BLUETOOTH_ALLOW_CONN_ALL_SCAN_ALLOW_LIST = 0x01,
+ BLUETOOTH_ALLOW_SCAN_ALL_CONN_ALLOW_LIST = 0x02,
+ BLUETOOTH_ALLOW_SCAN_CONN_ALLOW_LIST = 0x03,
} bluetooth_advertising_filter_policy_t;
/**
typedef enum {
BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD = 0x01,
BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE = 0x02,
+ BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_RESYNC = 0x03,
} bluetooth_gatt_service_change_type_t;
typedef enum {
* TDS transport Type
*/
typedef enum {
- BLUETOOTH_TDS_TRANSPORT_BT = 0x01, /* Transport type BR-EDR */
- BLUETOOTH_TDS_TRANSPORT_CUSTOM, /* Transport type custom */
+ BLUETOOTH_TDS_TRANSPORT_BT = 0x01, /* Transport type BR-EDR */
+ BLUETOOTH_TDS_TRANSPORT_CUSTOM, /* Transport type custom */
+ BLUETOOTH_TDS_TRANSPORT_WIFI_NAN, /* Wi-Fi Alliance Neighbor Awareness Networking */
+ BLUETOOTH_TDS_TRANSPORT_WIFI_SVC_ADV, /* Wi-Fi Alliance Service Advertisement */
/* ... */
BLUETOOTH_TDS_TRANSPORT_INVALID
} bluetooth_tds_transport_t;
* Advertising parameters
*/
typedef struct {
- float interval_min;
- float interval_max;
+ int interval_min;
+ int interval_max;
guint8 filter_policy;
guint8 type;
int tx_power_level;
+ gboolean is_legacy;
+ int primary_phy;
+ int secondary_phy;
} bluetooth_advertising_params_t;
/**
BLUETOOTH_LE_ACTIVE_SCAN
} bluetooth_le_scan_type_t;
+typedef enum {
+ BLUETOOTH_LE_SCAN_ALL = 0x00,
+ BLUETOOTH_LE_SCAN_LEGACY_ONLY,
+ BLUETOOTH_LE_SCAN_EXTENDED_ONLY
+} bluetooth_le_scan_role_t;
+
+typedef enum {
+ BLUETOOTH_ALL_PHY = 0x00,
+ BLUETOOTH_1M_PHY = 0x01,
+ BLUETOOTH_ONE_M_CODED_PHY = 0x03
+} bleutooth_le_scanning_phy_t;
+
/*
LE Connection Update
*/
/**< Base ID for MAP events */
#define BLUETOOTH_EVENT_MESH_BASE ((int)(BLUETOOTH_EVENT_MAP_BASE + 0x0020))
/**< Base ID for MAP events */
+#define BLUETOOTH_EVENT_L2CAP_LE_BASE ((int)(BLUETOOTH_EVENT_MESH_BASE + 0x0040))
+ /**< Base ID for L2CAP_LE events */
/**
* Bluetooth event type
BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED, /** <GATT Client service change event */
BLUETOOTH_EVENT_GATT_SERVER_ACQUIRE_WRITE, /** <GATT Characteristic/Descriptor Value change event */
BLUETOOTH_EVENT_GATT_SERVER_ACQUIRE_NOTIFY,
+ BLUETOOTH_EVENT_GATT_SERVER_PHY_READ, /**<Local Gatt Server PHY Read event */
+ BLUETOOTH_EVENT_GATT_SERVER_PHY_UPDATED, /**<Local Gatt Server PHY Updated event */
+ BLUETOOTH_EVENT_GATT_CLIENT_PHY_READ, /**<Gatt Client PHY Read event */
+ BLUETOOTH_EVENT_GATT_CLIENT_PHY_UPDATED, /**<Gatt Client PHY Updated event */
BLUETOOTH_EVENT_AG_CONNECTED = BLUETOOTH_EVENT_AUDIO_BASE, /**<AG service connected event*/
BLUETOOTH_EVENT_AG_DISCONNECTED, /**<AG service disconnected event*/
BLUETOOTH_EVENT_AG_SPEAKER_GAIN, /**<Speaker gain request event*/
BLUETOOTH_EVENT_MESH_MODEL_APPKEY_BIND,
BLUETOOTH_EVENT_MESH_MODEL_APPKEY_LIST,
BLUETOOTH_EVENT_MESH_MODEL_MSG_EXECUTED,
+ BLUETOOTH_EVENT_MESH_MODEL_MSG_RECEIVED,
BLUETOOTH_EVENT_MESH_MODEL_SUBSCRIPTION_LIST,
BLUETOOTH_EVENT_MESH_MODEL_SUBSCRIPTION_CONFGURED,
BLUETOOTH_EVENT_MESH_MODEL_VIRTUAL_SUBSCRIPTION_CONFGURED,
BLUETOOTH_EVENT_MESH_MODEL_PUBLICATION_STATUS,
+ BLUETOOTH_EVENT_MESH_JOIN_COMPLETED,
+ BLUETOOTH_EVENT_L2CAP_LE_DATA_RECEIVED = BLUETOOTH_EVENT_L2CAP_LE_BASE,
+ /**< L2CAP_LE data receive event */
+ BLUETOOTH_EVENT_L2CAP_LE_CONNECTED, /**< L2CAP_LE server/client connect */
+ BLUETOOTH_EVENT_L2CAP_LE_DISCONNECTED, /**< L2CAP_LE server/client disconnect */
+ BLUETOOTH_EVENT_L2CAP_LE_AUTHORIZE,
+ BLUETOOTH_EVENT_L2CAP_LE_SERVER_REMOVED
} bluetooth_event_type_t;
/**
} bluetooth_le_advertising_data_t;
typedef struct {
+ guint8 data[BLUETOOTH_EXTENDED_ADVERTISING_DATA_LENGTH_MAX];
+} bluetooth_extended_advertising_data_t;
+
+typedef struct{
+ gboolean use_reserved_slot;
+ gboolean is_legacy;
+} bluetooth_le_slot_and_adv_type_t;
+
+typedef struct {
+ int data_len; /**< manafacturer specific data length */
+ bluetooth_extended_advertising_data_t data; /**< manafacturer specific data */
+} bluetooth_le_extended_advertising_data_t;
+
+typedef struct {
bluetooth_device_address_t device_address; /**< device address */
- int addr_type; /**< address type*/
- int rssi; /**< received strength signal*/
+ int addr_type; /**< address type*/
+ int rssi; /**< received strength signal*/
+ int event_type;
+ int primary_phy;
+ int secondary_phy;
+ int advertising_sid;
+ int tx_power;
+ int periodic_adv_int;
+ bool is_extended;
+ /* TODO : Replace bluetooth_le_advertising_data_t adv_ind_data with
+ * bluetooth_le_extended_advertising_data_t once
+ * LE_EXTENDED feature is supported */
bluetooth_le_advertising_data_t adv_ind_data;
bluetooth_le_advertising_data_t scan_resp_data;
} bluetooth_le_device_info_t;
unsigned int status; /** < status of the MTU exchange */
} bluetooth_le_att_mtu_info_t;
+typedef struct {
+ bluetooth_device_address_t device_address; /**< device address */
+ int tx_phy; /** < tx_phy set for the gatt connection */
+ int rx_phy; /** < rx_phy set for the gatt connection */
+ int status; /** < status of the PHY */
+} bluetooth_le_phy_info_t;
+
/**
* structure to hold the paired device information
*/
} bluetooth_rfcomm_received_data_t;
/**
+ * Stucture to l2cap_le receive data
+ */
+typedef struct {
+ int socket_fd; /**< the socket fd */
+ int buffer_size; /**< the length of the receive buffer */
+ char *buffer; /**< the receive data buffer */
+} bluetooth_l2cap_le_received_data_t;
+
+/**
* HID Header type
*/
typedef enum {
} bluetooth_rfcomm_connection_request_t;
/**
+ * Stucture to l2cap_le connection
+ */
+typedef struct {
+ int socket_fd; /**< the socket fd */
+ int server_id; /* Server id */
+ int device_role; /** < Device role - L2CAP_LE_ROLE_SERVER or L2CAP_LE_ROLE_CLIENT */
+ bluetooth_device_address_t device_addr; /**< device address */
+ int psm;
+} bluetooth_l2cap_le_connection_t;
+
+/**
+ * Stucture to l2cap_le disconnection
+ */
+typedef struct {
+ int socket_fd; /**< the socket fd */
+ int device_role;
+ /** < Device role - L2CAP_LE_ROLE_SERVER or L2CAP_LE_ROLE_CLIENT */
+ bluetooth_device_address_t device_addr; /**< device address */
+ int psm;
+} bluetooth_l2cap_le_disconnection_t;
+
+/**
+ * Stucture to l2cap_le connection request
+ */
+typedef struct {
+ int socket_fd; /**< the socket fd */
+ bluetooth_device_address_t device_addr; /**< device address */
+} bluetooth_l2cap_le_connection_request_t;
+
+/**
* HDP QOS types
*/
typedef enum {
BLUETOOTH_DPM_POLICY_ALLOW,
BLUETOOTH_DPM_POLICY_DEVICE_RESTRICTION,
BLUETOOTH_DPM_POLICY_UUID_RESTRICTION,
- BLUETOOTH_DPM_POLICY_DEVICES_WHITELIST,
- BLUETOOTH_DPM_POLICY_DEVICES_BLACKLIST,
- BLUETOOTH_DPM_POLICY_UUIDS_WHITELIST,
- BLUETOOTH_DPM_POLICY_UUIDS_BLACKLIST,
+ BLUETOOTH_DPM_POLICY_DEVICES_ALLOWLIST,
+ BLUETOOTH_DPM_POLICY_DEVICES_BLOCKLIST,
+ BLUETOOTH_DPM_POLICY_UUIDS_ALLOWLIST,
+ BLUETOOTH_DPM_POLICY_UUIDS_BLOCKLIST,
BLUETOOTH_DPM_POLICY_ALLOW_OUTGOING_CALL,
BLUETOOTH_DPM_POLICY_PAIRING_STATE,
BLUETOOTH_DPM_POLICY_DESKTOP_CONNECTIVITY_STATE,
*
* @remark None
*/
-int bluetooth_set_advertising_data(int handle, const bluetooth_advertising_data_t *value, int length);
+int bluetooth_set_advertising_data(int handle, const bluetooth_advertising_data_t *value, int length, bool is_legacy);
/**
* @fn int bluetooth_check_privilege_advertising_parameter(void);
int bluetooth_set_scan_type(bluetooth_le_scan_type_t scan_type);
/**
+ * @fn intbluetooth_set_scan_phy(bleutooth_le_scanning_phy_t phy);
+ *ss
+ * @brief Set scan phy
+ *
+ * This function is used to set LE scan phy
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
+ *
+ * @exception None
+ * @param[in] phy - LE scanning PHY
+ *
+ * @remark None
+ */
+int bluetooth_set_le_scan_phy(bleutooth_le_scanning_phy_t phy);
+
+/**
+ * @fn intbluetooth_set_scan_phy(bluetooth_le_scan_role_t role);
+ *ss
+ * @brief Set scan role
+ *
+ * This function is used to set LE scan role
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
+ *
+ * @exception None
+ * @param[in] role - LE scanning role
+ *
+ * @remark None
+ */
+int bluetooth_set_le_scan_role(bluetooth_le_scan_role_t role);
+
+/**
* @fn int bluetooth_is_advertising(void)
* @brief Check for the advertising is in-progress or not.
*
int bluetooth_is_advertising(gboolean *is_advertising);
/**
- * @fn int bluetooth_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
- * @brief Add LE device to white list
+ * @fn int bluetooth_add_allow_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
+ * @brief Add LE device to allow list
*
- * This API is used to add LE device to white list
+ * This API is used to add LE device to allow list
* Before calling this API, make sure that the adapter is enabled. There is no callback event for
* this API.
*
* @remark None
* @see bluetooth_set_custom_advertising
*/
-int bluetooth_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type);
+int bluetooth_add_allow_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type);
/**
- * @fn int bluetooth_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
- * @brief Remove LE device from white list
+ * @fn int bluetooth_remove_allow_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
+ * @brief Remove LE device from allow list
*
- * This API is used to remove LE device from white list
+ * This API is used to remove LE device from allow list
* Before calling this API, make sure that the adapter is enabled. There is no callback event for
* this API.
*
* @remark None
* @see bluetooth_set_custom_advertising
*/
-int bluetooth_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type);
+int bluetooth_remove_allow_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type);
/**
- * @fn int bluetooth_clear_white_list(void)
- * @brief Clear white list
+ * @fn int bluetooth_clear_allow_list(void)
+ * @brief Clear allow list
*
- * This API is used to clear white list
+ * This API is used to clear allow list
* Before calling this API, make sure that the adapter is enabled. There is no callback event for
* this API.
*
* @remark None
* @see bluetooth_set_custom_advertising
*/
-int bluetooth_clear_white_list(void);
+int bluetooth_clear_allow_list(void);
/**
* @fn int bluetooth_le_conn_update(bluetooth_device_address_t *address,
unsigned int *mtu);
/**
+ * @fn int bluetooth_gatt_server_read_phy(const bluetooth_device_address_t *device_address)
+ * @brief Gets the PHY values set for a connection.
+ *
+ * This function is a asynchronous call. The updated PHYs are notified
+ * through callback event.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
+ *
+ * @exception None
+ * @param[in] address - remote device address value.
+ *
+ * @remark None
+ */
+int bluetooth_gatt_server_read_phy(const bluetooth_device_address_t *device_address);
+
+/**
+ * @fn int bluetooth_gatt_server_set_phy(const bluetooth_device_address_t *device_address,
+ int tx_phy, int rx_phy, int phy_options)
+ * @brief Request a change of the PHY values.
+ *
+ * This function is a asynchronous call. The updated PHYs are notified
+ * through callback event.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
+ *
+ * @exception None
+ * @param[in] address - remote device address value.
+ * @param[in] tx_phy The preferred sender PHY
+ * @param[in] rx_phy The preferred receiver PHY
+ * @param[in] phy_options The preferred coding to use when transmitting on LE CODED PHY
+ *
+ * @remark None
+ */
+int bluetooth_gatt_server_set_phy(const bluetooth_device_address_t *device_address,
+ int tx_phy, int rx_phy, int phy_options);
+
+/**
+ * @fn int bluetooth_gatt_client_read_phy(const bluetooth_device_address_t *device_address)
+ * @brief Gets the PHY values set for a connection.
+ *
+ * This function is a asynchronous call. The updated PHYs are notified
+ * through callback event.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
+ *
+ * @exception None
+ * @param[in] address - remote device address value.
+ *
+ * @remark None
+ */
+int bluetooth_gatt_client_read_phy(const bluetooth_device_address_t *device_address);
+
+/**
+ * @fn int bluetooth_gatt_client_set_phy(const bluetooth_device_address_t *device_address,
+ int tx_phy, int rx_phy, int phy_options)
+ * @brief Request a change of the PHY values.
+ *
+ * This function is a asynchronous call. The updated PHYs are notified
+ * through callback event.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
+ *
+ * @exception None
+ * @param[in] address - remote device address value.
+ * @param[in] tx_phy The preferred sender PHY
+ * @param[in] rx_phy The preferred receiver PHY
+ * @param[in] phy_options The preferred coding to use when transmitting on LE CODED PHY
+ *
+ * @remark None
+ */
+int bluetooth_gatt_client_set_phy(const bluetooth_device_address_t *device_address,
+ int tx_phy, int rx_phy, int phy_options);
+
+/**
* @fn int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
* bluetooth_device_address_t *id_address)
* @brief Gets the Identity address of remote device.
int bluetooth_dpm_is_uuid_restriction_active(bt_dpm_status_t *value);
/**
- * @fn int bluetooth_dpm_add_devices_to_blacklist(const bluetooth_device_address_t *device_address);
+ * @fn int bluetooth_dpm_add_devices_to_blocklist(const bluetooth_device_address_t *device_address);
*
- * @brief Adds the device to blacklist.
+ * @brief Adds the device to blocklist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_add_devices_to_blacklist(const bluetooth_device_address_t *device_address);
+int bluetooth_dpm_add_devices_to_blocklist(const bluetooth_device_address_t *device_address);
/**
- * @fn int bluetooth_dpm_add_devices_to_whitelist(const bluetooth_device_address_t *device_address);
+ * @fn int bluetooth_dpm_add_devices_to_allowlist(const bluetooth_device_address_t *device_address);
*
- * @brief Adds the device to whitelist.
+ * @brief Adds the device to allowlist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_add_devices_to_whitelist(const bluetooth_device_address_t *device_address);
+int bluetooth_dpm_add_devices_to_allowlist(const bluetooth_device_address_t *device_address);
/**
- * @fn int bluetooth_dpm_add_uuids_to_blacklist(const char *service_uuid);
+ * @fn int bluetooth_dpm_add_uuids_to_blocklist(const char *service_uuid);
*
- * @brief Adds the Service UUIDS to blacklist.
+ * @brief Adds the Service UUIDS to blocklist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_add_uuids_to_blacklist(const char *service_uuid);
+int bluetooth_dpm_add_uuids_to_blocklist(const char *service_uuid);
/**
- * @fn int bluetooth_dpm_add_uuids_to_whitelist(const char *service_uuid);
+ * @fn int bluetooth_dpm_add_uuids_to_allowlist(const char *service_uuid);
*
- * @brief Adds the Service UUIDS to whitelist.
+ * @brief Adds the Service UUIDS to allowlist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_add_uuids_to_whitelist(const char *service_uuid);
+int bluetooth_dpm_add_uuids_to_allowlist(const char *service_uuid);
/**
- * @fn int bluetooth_dpm_clear_devices_from_blacklist();
+ * @fn int bluetooth_dpm_clear_devices_from_blocklist();
*
- * @brief Clears the devices from blacklist.
+ * @brief Clears the devices from blocklist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_clear_devices_from_blacklist(void);
+int bluetooth_dpm_clear_devices_from_blocklist(void);
/**
- * @fn int bluetooth_dpm_clear_devices_from_whitelist();
+ * @fn int bluetooth_dpm_clear_devices_from_allowlist();
*
- * @brief Clears the devices from whitelist.
+ * @brief Clears the devices from allowlist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_clear_devices_from_whitelist(void);
+int bluetooth_dpm_clear_devices_from_allowlist(void);
/**
- * @fn int bluetooth_dpm_clear_uuids_from_blacklist();
+ * @fn int bluetooth_dpm_clear_uuids_from_blocklist();
*
- * @brief Clears the uuids from blacklist.
+ * @brief Clears the uuids from blocklist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_clear_uuids_from_blacklist(void);
+int bluetooth_dpm_clear_uuids_from_blocklist(void);
/**
- * @fn int bluetooth_dpm_clear_uuids_from_whitelist();
+ * @fn int bluetooth_dpm_clear_uuids_from_allowlist();
*
- * @brief Clears the uuids from whitelist.
+ * @brief Clears the uuids from allowlist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_clear_uuids_from_whitelist(void);
+int bluetooth_dpm_clear_uuids_from_allowlist(void);
/**
- * @fn int bluetooth_dpm_get_devices_from_blacklist(bt_dpm_device_list_t *device_list);
+ * @fn int bluetooth_dpm_get_devices_from_blocklist(bt_dpm_device_list_t *device_list);
*
- * @brief reads the devices from blacklist.
+ * @brief reads the devices from blocklist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_get_devices_from_blacklist(bt_dpm_device_list_t *device_list);
+int bluetooth_dpm_get_devices_from_blocklist(bt_dpm_device_list_t *device_list);
/**
- * @fn int bluetooth_dpm_get_devices_from_whitelist(bt_dpm_device_list_t *device_list);
+ * @fn int bluetooth_dpm_get_devices_from_allowlist(bt_dpm_device_list_t *device_list);
*
- * @brief reads the devices from whitelist.
+ * @brief reads the devices from allowlist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_get_devices_from_whitelist(bt_dpm_device_list_t *device_list);
+int bluetooth_dpm_get_devices_from_allowlist(bt_dpm_device_list_t *device_list);
/**
- * @fn int bluetooth_dpm_get_uuids_from_blacklist(bt_dpm_uuids_list_t *uuid_list);
+ * @fn int bluetooth_dpm_get_uuids_from_blocklist(bt_dpm_uuids_list_t *uuid_list);
*
- * @brief reads the uuids from blacklist.
+ * @brief reads the uuids from blocklist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_get_uuids_from_blacklist(bt_dpm_uuids_list_t *uuid_list);
+int bluetooth_dpm_get_uuids_from_blocklist(bt_dpm_uuids_list_t *uuid_list);
/**
- * @fn int bluetooth_dpm_get_uuids_from_whitelist(bt_dpm_uuids_list_t *uuid_list);
+ * @fn int bluetooth_dpm_get_uuids_from_allowlist(bt_dpm_uuids_list_t *uuid_list);
*
- * @brief reads the uuids from whitelist.
+ * @brief reads the uuids from allowlist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_get_uuids_from_whitelist(bt_dpm_uuids_list_t *uuid_list);
+int bluetooth_dpm_get_uuids_from_allowlist(bt_dpm_uuids_list_t *uuid_list);
/**
- * @fn int bluetooth_dpm_remove_device_from_whitelist(const bluetooth_device_address_t *device_address);
+ * @fn int bluetooth_dpm_remove_device_from_allowlist(const bluetooth_device_address_t *device_address);
*
- * @brief Removes the device from whitelist.
+ * @brief Removes the device from allowlist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_remove_device_from_whitelist(const bluetooth_device_address_t *device_address);
+int bluetooth_dpm_remove_device_from_allowlist(const bluetooth_device_address_t *device_address);
/**
- * @fn int bluetooth_dpm_remove_device_from_blacklist(const bluetooth_device_address_t *device_address);
+ * @fn int bluetooth_dpm_remove_device_from_blocklist(const bluetooth_device_address_t *device_address);
*
- * @brief Removes the device from blacklist.
+ * @brief Removes the device from blocklist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_remove_device_from_blacklist(const bluetooth_device_address_t *device_address);
+int bluetooth_dpm_remove_device_from_blocklist(const bluetooth_device_address_t *device_address);
/**
- * @fn int bluetooth_dpm_remove_uuid_from_whitelist(const char *service_uuid);
+ * @fn int bluetooth_dpm_remove_uuid_from_allowlist(const char *service_uuid);
*
- * @brief Removes the Service UUIDS from whitelist.
+ * @brief Removes the Service UUIDS from allowlist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_remove_uuid_from_whitelist(const char *service_uuid);
+int bluetooth_dpm_remove_uuid_from_allowlist(const char *service_uuid);
/**
- * @fn int bluetooth_dpm_remove_uuid_from_blacklist(const char *service_uuid);
+ * @fn int bluetooth_dpm_remove_uuid_from_blocklist(const char *service_uuid);
*
- * @brief Removes the Service UUIDS from blacklist.
+ *
+ * @brief Removes the Service UUIDS from blocklist.
*
* This function is a synchronous call.
*
*
* @remark None
*/
-int bluetooth_dpm_remove_uuid_from_blacklist(const char *service_uuid);
+int bluetooth_dpm_remove_uuid_from_blocklist(const char *service_uuid);
/**
* @fn int bluetooth_dpm_set_allow_outgoing_call(bt_dpm_status_t value);
*
* This function is a synchronous call.
*
- * @return BLUETOOTH_ERROR_NONE - Succeess \n
+ * @return BLUETOOTH_ERROR_NONE - Success \n
* BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter (NULL buffer) \n
* BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
* BLUETOOTH_ERROR_INTERNAL - Internal error \n
*
* This function is a synchronous call.
*
- * @return BLUETOOTH_ERROR_NONE - Succeess \n
+ * @return BLUETOOTH_ERROR_NONE - Success \n
* BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter (NULL buffer) \n
* BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
* BLUETOOTH_ERROR_INTERNAL - Internal error \n
int bluetooth_is_le_coded_phy_supported(gboolean *is_supported);
/**
+ * @fn int bluetooth_is_le_extended_advertising_supported(gboolean *is_supported)
+ * @brief Check if Adapter supports LE Extended Advertising feature or not.
+ *
+ * This API is used to check whether LE Adapter supports LE Extended Advertising feature, which is introduced
+ * in BT 5.0 specification.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter (NULL buffer) \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal error \n
+ * @param[out] is_supported. This boolean variable indicates whether LE Extended Advertising is supported or not
+ *
+ * @remark None
+ */
+int bluetooth_is_le_extended_advertising_supported(gboolean *is_supported);
+
+/**
+ * @fn int bluetooth_is_le_extended_scan_supported(gboolean *is_supported)
+ * @brief Check if Adapter supports LE Extended Scan feature or not.
+ *
+ * This API is used to check whether LE Adapter supports LE Extended Scan feature, which is introduced
+ * in BT 5.0 specification.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter (NULL buffer) \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal error \n
+ * @param[out] is_supported. This boolean variable indicates whether LE Extended Scan is supported or not
+ *
+ * @remark None
+ */
+int bluetooth_is_le_extended_scan_supported(gboolean *is_supported);
+
+/**
+ * @fn int bluetooth_le_get_maximum_advertising_data_length(gint *data_length)
+ * @brief gives the maximum advertising data length supported by controller.
+ *
+ * This API is used to get the maximum advertising data length supported by controller. This feature is introduced
+ * in BT 5.0 specification.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter (NULL buffer) \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal error \n
+ * @param[out] data_length. This integer variable indicates the maximum advertising data length supported by the controller
+ *
+ * @remark None
+ */
+int bluetooth_le_get_maximum_advertising_data_length(gint *data_length);
+
+/**
+ * @fn int bluetooth_l2cap_le_create_socket(int psm)
+ * @brief Register l2cap_le socket with a specific PSM
+ *
+ *
+ * This API register l2cap_le socket with the given PSM. The return value of this API is the socket
+ * descriptor of the server.
+ * This is the first API which is called to create the server. Once we created the server socket,
+ * we will listen on that return socket.
+ * So a bluetooth_l2cap_le_listen_and_accept should follow this API call. This is a synchronous call.
+ *
+ *
+ * @return socket FD on Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal error\n
+ * BLUETOOTH_ERROR_MAX_CONNECTION - Maximum connection reached\n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * @param[in] int psm
+ *
+ * @remark None
+ * @see bluetooth_l2cap_le_listen_and_accept, bluetooth_l2cap_le_remove_socket
+ *
+ @code
+
+ int test_psm = 0;
+ fd = bluetooth_l2cap_le_create_socket(test_psm);
+
+ @endcode
+ */
+int bluetooth_l2cap_le_create_socket(int psm);
+
+/**
+ * @fn int bluetooth_l2cap_le_remove_socket(int socket_fd)
+ * @brief De-register the l2cap_le socket
+ *
+ *
+ * This API deregister l2cap_le socket with the given socket fd. If the remote device is
+ * already connected then we will receive the BLUETOOTH_EVENT_L2CAP_LE_DISCONNECTED with socket
+ * descriptor else no event will come. We will call this API only after the
+ * bluetooth_l2cap_le_listen_and_accept.
+ * This is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
+ * BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * @param[in] int socket_fd
+ *
+ * @remark None
+ * @see bluetooth_l2cap_le_create_socket, bluetooth_l2cap_le_listen_and_accept
+ *
+ @code
+ void bt_event_callback(int event, bluetooth_event_param_t *param)
+ {
+ switch(event)
+ {
+ case BLUETOOTH_EVENT_L2CAP_LE_DISCONNECTED:
+ {
+ bluetooth_l2cap_le_connection_t *discon_ind =
+ (bluetooth_l2cap_le_connection_t *)param->param_data;
+
+ printf("\nDisconnected from FD %d", discon_ind->socket_fd);
+ }
+ }
+ }
+
+ ...
+
+ int ret = 0;
+ fd = bluetooth_l2cap_le_create_socket(test_psm);
+ ret = bluetooth_l2cap_le_listen_and_accept(fd, 1);
+ ....
+ ret = bluetooth_l2cap_le_remove_socket(fd);
+ @endcode
+ */
+int bluetooth_l2cap_le_remove_socket(int socket_fd);
+
+/**
+ * @fn int bluetooth_l2cap_le_server_disconnect(int socket_fd)
+ * @brief Disconnect l2cap_le connection
+ *
+ *
+ * Disconnect a specific(device node fd) l2cap_le connection. This is a Synchronous call and there
+ * is no callback events for this API. We have to provide the valid client fd to disconnect from the
+ * remote server.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * BLUETOOTH_ERROR_NOT_CONNECTED - Not connected \n
+ * @param[in] int socket_fd
+ *
+ * @remark None
+ *
+ @code
+
+ ret = bluetooth_l2cap_le_server_disconnect(g_ret_fd);
+ if (ret < 0)
+ printf("Disconnection failed");
+ else
+ printf("Disconnection Success");
+
+ @endcode
+ */
+int bluetooth_l2cap_le_server_disconnect(int socket_fd);
+
+/**
+ * @fn int bluetooth_l2cap_le_listen_and_accept(int socket_fd, int max_pending_connection)
+ * @brief L2CAP_LE socket listen
+ *
+ *
+ * This API make l2cap_le socket listen and accept with socket. We will call this API immediately
+ * after the bluetooth_l2cap_le_create_socket API.
+ * This API listen for the incoming connection and once it receives a connection, it will give
+ * BLUETOOTH_EVENT_L2CAP_LE_CONNECTED
+ * event to the application. This is an Asynchronous API call.
+ *
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * BLUETOOTH_ERROR_CONNECTION_ERROR - Listen failed \n
+
+ * @param[in] int socket_fd
+ * @param[in] max pending connection.
+ *
+ * @remark None
+ * @see bluetooth_l2cap_le_create_socket
+ *
+ @code
+ void bt_event_callback(int event, bluetooth_event_param_t* param)
+ {
+ switch(event)
+ {
+ case BLUETOOTH_EVENT_L2CAP_LE_CONNECTED:
+ {
+ bluetooth_l2cap_le_connection_t *conn_ind =
+ (bluetooth_l2cap_le_connection_t *)param->param_data;
+
+ printf("\nConnected from FD %d", conn_ind->socket_fd);
+ }
+ }
+ }
+
+ ...
+
+ int ret = 0;
+ fd = bluetooth_l2cap_le_create_socket(test_psm);
+ ret = bluetooth_l2cap_le_listen_and_accept(fd, 1);
+
+ @endcode
+ */
+int bluetooth_l2cap_le_listen_and_accept(int socket_fd, int max_pending_connection);
+
+/**
+ * @fn int bluetooth_l2cap_le_listen(int socket_fd, int max_pending_connection)
+ * @brief L2cap_le socket listen
+ *
+ *
+ * This API make l2cap_le socket listen and accept with socket. We will call this API immediately
+ * after the bluetooth_l2cap_le_create_socket API.
+ * This API listen for the incoming connection and once it receives a connection, it will give
+ * BLUETOOTH_EVENT_L2CAP_LE_AUTHORIZE
+ * event to the application. This is an Asynchronous API call.
+ *
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * BLUETOOTH_ERROR_CONNECTION_ERROR - Listen failed \n
+
+ * @param[in] int socket_fd
+ * @param[in] max pending connection.
+ *
+ * @remark None
+ * @see bluetooth_l2cap_le_create_socket
+ *
+ @code
+ void bt_event_callback(int event, bluetooth_event_param_t* param)
+ {
+ switch(event)
+ {
+ case BLUETOOTH_EVENT_L2CAP_LE_AUTHORIZE:
+ {
+ char *name = (char *)param->param_data;
+
+ printf("\nConnected from %s", name);
+
+ bluetooth_l2cap_le_accept_connection();
+ }
+ }
+ }
+
+ ...
+
+ int ret = 0;
+ fd = bluetooth_l2cap_le_create_socket(test_psm);
+ ret = bluetooth_l2cap_le_listen(fd, 1);
+
+ @endcode
+ */
+int bluetooth_l2cap_le_listen(int socket_fd, int max_pending_connection);
+
+/**
+ * @fn int bluetooth_l2cap_le_accept_connection()
+ * @brief Accepts the authorization request indicated by the event
+ * BLUETOOTH_EVENT_L2CAP_LE_AUTHORIZE.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal error \n
+ *
+ * @param[in] the socket fd of the server
+ * @param[out] the socket fd of the client
+ *
+ * @exception None
+ * @remark None
+ * @see bluetooth_l2cap_le_reject_connection
+ */
+int bluetooth_l2cap_le_accept_connection(int server_fd);
+
+/**
+ * @fn int bluetooth_l2cap_le_reject_connection()
+ * @brief Rejects the authorization request indicated by the event
+ * BLUETOOTH_EVENT_L2CAP_LE_AUTHORIZE.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal error \n
+ *
+ * @param[in] the socket fd of the server
+ *
+ * @exception None
+ * @remark None
+ * @see bluetooth_l2cap_le_accept_connection
+ */
+int bluetooth_l2cap_le_reject_connection(int server_fd);
+
+/**
+ * @fn gboolean bluetooth_l2cap_le_is_server_psm_available(int psm)
+ * @brief Informs whether l2cap_le server psm is available or not.
+ *
+ * This function is a synchronous call.
+ *
+ * @return TRUE - L2CAP_LE PSM is available \n
+ * FALSE - L2CAP_LE PSM is not available \n
+ *
+ * @param[in] psm (int)
+ *
+ * @exception None
+ *
+ * @remark None
+ */
+gboolean bluetooth_l2cap_le_is_server_psm_available(int psm);
+
+/**
+ * @fn int bluetooth_l2cap_le_connect(const bluetooth_device_address_t *remote_bt_address,
+ * int psm)
+ * @brief Connect to the remote device l2cap_le *
+ *
+ * Connect to a specific l2cap_le socket on a remote device psm. This is a Async call. Once
+ * the connection is successful callback BLUETOOTH_EVENT_L2CAP_LE_CONNECTED events is generated,
+ * which contains the socket_fd, device role (L2CAP_LE_ROLE_SERVER/L2CAP_LE_ROLE_CLIENT), device addess
+ * etc. The socket_fd can be further used to send the data. It better to do a ble scanning before
+ * initiating a connection.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * BLUETOOTH_ERROR_CONNECTION_BUSY - Connection in progress \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal Error\n
+ * @param[in] bluetooth_device_address_t remote bt_address
+ * @param[in] int psm
+ * @remark None
+ * @see bluetooth_l2cap_le_disconnect, bluetooth_l2cap_le_write
+ *
+ @code
+
+ void bt_event_callback(int event, bluetooth_event_param_t *param)
+ {
+ switch(event)
+ {
+ case BLUETOOTH_EVENT_L2CAP_LE_CONNECTED:
+ {
+ bluetooth_l2cap_le_connection_t *conn_ind =
+ (bluetooth_l2cap_le_connection_t *)param->param_data;
+
+ printf("\nConnected from FD %d, Role = %s", conn_ind->socket_fd,
+ (conn_ind->device_role == L2CAP_LE_ROLE_SERVER) ?
+ "SERVER" : "CLIENT");
+ }
+ }
+ }
+
+ bluetooth_device_address_t remote_address = {{0},};
+ remote_address.addr[0] = 0x0; remote_address.addr[1] = 0x0A; remote_address.addr[2] = 0x3A;
+ remote_address.addr[3]= 0x54; remote_address.addr[4] = 0x19; remote_address.addr[5]= 0x36;
+
+ ret = bluetooth_l2cap_le_connect(&remote_address, test_psm);
+ if (ret < 0)
+ printf("Connection failed, Reason = %d", ret);
+ else
+ printf("Connection Success, Ret = %d", ret);
+
+ @endcode
+ */
+int bluetooth_l2cap_le_connect(const bluetooth_device_address_t *remote_bt_address,
+ int psm);
+
+/**
+ * @fn int bluetooth_l2cap_le_disconnect(int socket_fd)
+ * @brief Disconnect l2cap_le connection
+ *
+ *
+ * Disconnect a specific(device node fd) L2CAP_LE connection. This is a Synchronous call and there
+ * is no callback events for this API. We have to provide the valid client fd to disconnect from the
+ * remote server.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * BLUETOOTH_ERROR_NOT_CONNECTED - Not connected \n
+ * @param[in] int remote socket_fd
+ *
+ * @remark None
+ * @see bluetooth_l2cap_le_connect
+ *
+ @code
+
+ ret = bluetooth_l2cap_le_disconnect(g_ret_fd);
+ if (ret < 0)
+ printf("Disconnection failed");
+ else
+ printf("Disconnection Success");
+
+ @endcode
+ */
+
+int bluetooth_l2cap_le_disconnect(int socket_fd);
+
+/**
+ * @fn int bluetooth_l2cap_le_write (int fd, const char *buf, int length)
+ * @brief Write to l2cap_le connection
+ *
+ *
+ * This API is used to send the data over the l2cap_le connection. This is a
+ * synchronous API. The same API is used to send the data for server and the client.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * BLUETOOTH_ERROR_NOT_IN_OPERATION - The Fd is currently not in operation\n
+ * @param[in] int fd
+ * @param[in] const char *buff Data buffer to send
+ * @param[in] int length Length of the data
+ *
+ * @remark None
+ * @see bluetooth_l2cap_le_connect
+ *
+ @code
+ char *buff = "Test data 123456789"
+ ret = bluetooth_l2cap_le_write(g_ret_fd, buff, 15);
+ if (ret < 0)
+ printf("Send failed");
+ else
+ printf("Send success");
+
+ @endcode
+ */
+int bluetooth_l2cap_le_write(int fd, const char *buf, int length);
+
+/**
+ * @fn gboolean bluetooth_l2cap_le_client_is_connected(
+ * const bluetooth_device_address_t *device_address, gboolean *connected)
+ * @brief Informs whether l2cap_le client is connected.
+ *
+ * This function is a synchronous call.
+ *
+ * @return TRUE - L2CAP_LE client is connected \n
+ * FALSE - L2CAP_LE client is not connected \n
+ *
+ * @exception None
+ *
+ * @remark None
+ */
+int bluetooth_l2cap_le_client_is_connected(
+ const bluetooth_device_address_t *device_address, gboolean *connected);
+
+/**
+ * @fn gboolean bluetooth_l2cap_le_server_is_connected(
+ * const bluetooth_device_address_t *device_address, gboolean *connected)
+ * @brief Informs whether l2cap_le server is connected.
+ *
+ * This function is a synchronous call.
+ *
+ * @return TRUE - L2CAP_LE server is connected \n
+ * FALSE - L2CAP_LE server is not connected \n
+ *
+ * @exception None
+ *
+ * @remark None
+ */
+int bluetooth_l2cap_le_server_is_connected(
+ const bluetooth_device_address_t *device_address, gboolean *connected);
+
+/**
+ * @fn gboolean bluetooth_l2cap_le_get_psm(int server_fd, int *psm)
+ * @brief gives the psm of the specific l2cap_le socket connection.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
+ *
+ * @param[in] the socket fd of the server
+ * @param[out] int *psm
+ *
+ * @exception None
+ *
+ * @remark None
+ */
+int bluetooth_l2cap_le_get_psm(int id, int *psm);
+
+/**
+ * @fn gboolean bluetooth_l2cap_le_get_max_buffer_size(int *size)
+ * @brief gives the maximum size of buffer.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
+ *
+ * @param[out] int *size
+ *
+ * @exception None
+ *
+ * @remark None
+ */
+int bluetooth_l2cap_le_get_max_buffer_size(int *size);
+
+/**
* @}
*/