return result;
}
+BT_EXPORT_API int bluetooth_get_gatt_data_batching_available_packets(
+ int *available_packets)
+{
+ int result;
+ int available;
+
+ BT_CHECK_PARAMETER(available_packets, return);
+ BT_CHECK_ENABLED_ANY(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_GATT_DATA_BATCHING_AVAILABLE_PACKETS,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ available = g_array_index(out_param, guint, 0);
+ BT_DBG("available_packets: %d", available);
+ *available_packets = available;
+ }
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_enable_gatt_data_batching(
+ const bluetooth_device_address_t *device_address, int packet_threshold, int timeout)
+{
+ int result;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_ENABLED_ANY(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
+ g_array_append_vals(in_param2, &packet_threshold, sizeof(int));
+ g_array_append_vals(in_param3, &timeout, sizeof(int));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_GATT_DATA_BATCHING,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_disable_gatt_data_batching(
+ const bluetooth_device_address_t *device_address)
+{
+ int result;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_ENABLED_ANY(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_GATT_DATA_BATCHING,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
BT_EXPORT_API int bluetooth_enable_rssi(const bluetooth_device_address_t *remote_address,
int link_type, bt_rssi_threshold_t *rssi_threshold)
{
return BT_STATUS_UNSUPPORTED;
}
+bt_status_t btif_gatt_get_data_batching_available_packets(unsigned int *available_packets)
+{
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ GVariant *ret;
+ guint32 available_pkts;
+
+ CHECK_BTGATT_INIT();
+
+ if (available_packets == NULL) {
+ ERR("available_packets is NULL");
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ proxy = _bt_hal_get_adapter_proxy();
+ if (proxy == NULL) {
+ ERR("proxy is NULL");
+ return BT_STATUS_FAIL;
+ }
+
+ ret = g_dbus_proxy_call_sync(proxy, "GetLeBatchingAvailablePkts",
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1, NULL, &error);
+ if (error) {
+ int result = BT_STATUS_FAIL;
+
+ ERR("SetLeBatchingParam Fail: %s", error->message);
+ if (g_strrstr(error->message, "Operation is not supported"))
+ result = BT_STATUS_UNSUPPORTED;
+
+ g_clear_error(&error);
+ return result;
+ }
+ g_variant_get(ret, "(u)", &available_pkts);
+ g_variant_unref(ret);
+
+ INFO("GATT Batching available packets: %u", available_pkts);
+ *available_packets = available_pkts;
+ return BT_STATUS_SUCCESS;
+}
+
+bt_status_t btif_gatt_enable_data_batching(const bt_bdaddr_t *bd_addr, int packet_threshold, int timeout)
+{
+ char device_address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ GVariant *ret;
+ CHECK_BTGATT_INIT();
+
+ if (bd_addr == NULL) {
+ ERR("bd_addr is NULL");
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ proxy = _bt_hal_get_adapter_proxy();
+ if (proxy == NULL) {
+ ERR("proxy is NULL");
+ return BT_STATUS_FAIL;
+ }
+
+ _bt_hal_convert_addr_type_to_string(device_address,
+ (unsigned char *)bd_addr->address);
+ ret = g_dbus_proxy_call_sync(proxy, "EnableLeBatching",
+ g_variant_new("(sii)", device_address, packet_threshold, timeout),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1, NULL, &error);
+ if (error) {
+ int result = BT_STATUS_FAIL;
+
+ ERR("SetLeBatchingParam Fail: %s", error->message);
+ if (g_strrstr(error->message, "Operation is not supported"))
+ result = BT_STATUS_UNSUPPORTED;
+ else if (g_strrstr(error->message, "Invalid arguments"))
+ result = BT_STATUS_PARM_INVALID;
+
+ g_clear_error(&error);
+ return result;
+ }
+ g_variant_unref(ret);
+
+ INFO("GATT Batching is enabled");
+ return BT_STATUS_SUCCESS;
+}
+
+bt_status_t btif_gatt_disable_data_batching(const bt_bdaddr_t *bd_addr)
+{
+ char device_address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ GVariant *ret;
+ CHECK_BTGATT_INIT();
+
+ if (bd_addr == NULL) {
+ ERR("bd_addr is NULL");
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ proxy = _bt_hal_get_adapter_proxy();
+ if (proxy == NULL) {
+ ERR("proxy is NULL");
+ return BT_STATUS_FAIL;
+ }
+
+ _bt_hal_convert_addr_type_to_string(device_address,
+ (unsigned char *)bd_addr->address);
+ ret = g_dbus_proxy_call_sync(proxy, "DisableLeBatching",
+ g_variant_new("(s)", device_address),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1, NULL, &error);
+ if (error) {
+ int result = BT_STATUS_FAIL;
+
+ ERR("SetLeBatching Fail: %s", error->message);
+ if (g_strrstr(error->message, "Operation is not supported"))
+ result = BT_STATUS_UNSUPPORTED;
+
+ g_clear_error(&error);
+ return result;
+ }
+ g_variant_unref(ret);
+
+ INFO("GATT Batching is disabled");
+ return BT_STATUS_SUCCESS;
+}
+
const btgatt_client_interface_t btgatt_client_interface = {
.register_client = btif_gattc_register_client,
.unregister_client = btif_gattc_unregister_client,
.batchscan_dis_batch_scan = batchscan_dis_batch_scan,
.batchscan_read_reports = batchscan_read_reports,
.add_connection_info = btif_gattc_add_connection_info,
+ .get_data_batching_available_packets = btif_gatt_get_data_batching_available_packets,
+ .enable_data_batching = btif_gatt_enable_data_batching,
+ .disable_data_batching = btif_gatt_disable_data_batching,
};
static hal_gattc_server_info_t *__bt_find_gatt_conn_info(const bt_bdaddr_t *serv_addr)
/** Adds a connection info in list */
bt_status_t (*add_connection_info)(const bt_bdaddr_t *bd_addr, int conn_id, int server_inst_id);
+
+ /** Get data batching available packets */
+ bt_status_t (*get_data_batching_available_packets)(unsigned int *available_packets);
+
+ /** Enable data batching */
+ bt_status_t (*enable_data_batching)(const bt_bdaddr_t *bd_addr, int packet_threshold, int timeout);
+
+ /** Disable data batching */
+ bt_status_t (*disable_data_batching)(const bt_bdaddr_t *bd_addr);
} btgatt_client_interface_t;
__END_DECLS
oal_status_t gattc_configure_mtu(int conn_id, int mtu);
+oal_status_t gatt_get_data_batching_available_packets(
+ unsigned int *available_packets);
+
+oal_status_t gatt_enable_data_batching(bt_address_t * address,
+ int packet_threshold, int timeout);
+
+oal_status_t gatt_disable_data_batching(bt_address_t * address);
+
#endif /* OAL_GATT_H_ */
BT_ERR("Gatt client configure_mtu error: %s", status2string(ret));
return convert_to_oal_status(ret);
}
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gatt_get_data_batching_available_packets(
+ unsigned int *available_packets)
+{
+ int ret;
+
+ ret = gatt_api->client->get_data_batching_available_packets(available_packets);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT data batching failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gatt_enable_data_batching(bt_address_t * address,
+ int packet_threshold, int timeout)
+{
+ int ret;
+
+ ret = gatt_api->client->enable_data_batching((bt_bdaddr_t *)address, packet_threshold, timeout);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT data batching failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gatt_disable_data_batching(bt_address_t * address)
+{
+ int ret;
+
+ ret = gatt_api->client->disable_data_batching((bt_bdaddr_t *)address);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT data batching failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
return OAL_STATUS_SUCCESS;
}
}
break;
}
+ /* Sync */
+ case BT_GET_GATT_DATA_BATCHING_AVAILABLE_PACKETS: {
+ guint available_packets = 0;
+
+ result = _bt_gatt_get_data_batching_available_packets(&available_packets);
+ BT_DBG("LE batching available packets %u", available_packets);
+ if (result == BLUETOOTH_ERROR_NONE) {
+ g_array_append_vals(*out_param1, &available_packets,
+ sizeof(guint));
+ }
+
+ break;
+ }
+ /* Sync */
+ case BT_ENABLE_GATT_DATA_BATCHING: {
+ bluetooth_device_address_t address = { {0} };
+ int packet_threshold;
+ int timeout;
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+ __bt_service_get_parameters(in_param2,
+ &packet_threshold, sizeof(int));
+ __bt_service_get_parameters(in_param3,
+ &timeout, sizeof(int));
+ result = _bt_gatt_enable_data_batching(&address, packet_threshold, timeout);
+
+ break;
+ }
+ /* Sync */
+ case BT_DISABLE_GATT_DATA_BATCHING: {
+ bluetooth_device_address_t address = { {0} };
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+ result = _bt_gatt_disable_data_batching(&address);
+
+ break;
+ }
+
case BT_GATT_GET_PRIMARY_SERVICES: {
char *addr;
case BT_LE_OOB_READ_LOCAL_DATA:
case BT_LE_OOB_ADD_REMOTE_DATA:
+ case BT_GET_GATT_DATA_BATCHING_AVAILABLE_PACKETS:
+ case BT_ENABLE_GATT_DATA_BATCHING:
+ case BT_DISABLE_GATT_DATA_BATCHING:
+
case BT_LE_IPSP_INIT:
case BT_LE_IPSP_DEINIT:
case BT_LE_IPSP_CONNECT:
}
}
+int _bt_gatt_get_data_batching_available_packets(
+ guint *available_packets)
+{
+ int ret = OAL_STATUS_SUCCESS;
+
+ BT_CHECK_PARAMETER(available_packets, return);
+
+ ret = gatt_get_data_batching_available_packets(available_packets);
+ if (ret != OAL_STATUS_SUCCESS) {
+ BT_ERR("ret: %d", ret);
+ if (ret == OAL_STATUS_NOT_SUPPORT)
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_gatt_enable_data_batching(bluetooth_device_address_t *address,
+ int packet_threshold, int timeout)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char remote_address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ BT_CHECK_PARAMETER(address, return);
+
+ _bt_convert_addr_type_to_string(remote_address, address->addr);
+ BT_INFO("Enable GATT data batching. address[%s] packet_threshold[%d] timeout[%d]",
+ remote_address, packet_threshold, timeout);
+
+ ret = gatt_enable_data_batching((bt_address_t*)(address), packet_threshold, timeout);
+
+ if (ret != OAL_STATUS_SUCCESS) {
+ BT_ERR("ret: %d", ret);
+ if (ret == OAL_STATUS_INVALID_PARAM)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+ else if (ret == OAL_STATUS_NOT_SUPPORT)
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_gatt_disable_data_batching(bluetooth_device_address_t *address)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char remote_address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ BT_CHECK_PARAMETER(address, return);
+
+ _bt_convert_addr_type_to_string(remote_address, address->addr);
+ BT_INFO("Disable GATT data batching. address[%s]", remote_address);
+
+ ret = gatt_disable_data_batching((bt_address_t*)(address));
+
+ if (ret != OAL_STATUS_SUCCESS) {
+ BT_ERR("ret: %d", ret);
+ if (ret == OAL_STATUS_NOT_SUPPORT)
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
#endif
int _bt_connect_le_device(bluetooth_device_address_t *address,
int auto_connect, int client_id);
+int _bt_gatt_get_data_batching_available_packets(
+ guint *available_packets);
+
+int _bt_gatt_enable_data_batching(bluetooth_device_address_t *address,
+ int packet_threshold, int timeout);
+
+int _bt_gatt_disable_data_batching(bluetooth_device_address_t *address);
+
int _bt_gatt_get_primary_services(char *address);
int _bt_gatt_get_all_characteristic(bluetooth_gatt_client_svc_prop_info_t *svc);
int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address);
#endif
+int bluetooth_get_gatt_data_batching_available_packets(
+ int *available_packets);
+
+int bluetooth_enable_gatt_data_batching(
+ const bluetooth_device_address_t *device_address, int packet_threshold, int timeout);
+
+int bluetooth_disable_gatt_data_batching(
+ const bluetooth_device_address_t *device_address);
+
/**
* @fn int bluetooth_gatt_discover_characteristic_descriptor(const char *characteristic_handle);
*
BT_GET_ATT_MTU,
BT_GET_DEVICE_IDA,
BT_SET_LE_STATIC_RANDOM_ADDRESS,
+
+ BT_GET_GATT_DATA_BATCHING_AVAILABLE_PACKETS,
+ BT_ENABLE_GATT_DATA_BATCHING,
+ BT_DISABLE_GATT_DATA_BATCHING,
+
BT_HDP_CONNECT = BT_FUNC_HDP_BASE,
BT_HDP_DISCONNECT,
BT_HDP_SEND_DATA,