#define DEV_APPEARANCE 0x0000
#define DEFAULT_GATT_CLIENT_UUID "0000A00A-1111-1111-0123-456789ABCDEF"
-#define MAX_PROP_LEN 90
-#define MAX_PERM_LEN 70
+#define MAX_PROP_LEN 95 /* SVACE WGID: 324403*/
+#define MAX_PERM_LEN 80 //Fix for svace wgid:324402
-#define NUM_SERVER_INST 10 // Maximum slots supported by stack is set to 10
#define CHECK_OAL_GATT_ENABLED() \
do { \
if (gatt_api == NULL) { \
#define CHECK_SERVER_INSTANCE(instance_id) \
do { \
- if (instance_id < 1 || instance_id > NUM_SERVER_INST) { \
+ if (instance_id < 1) { \
BT_ERR("Invalid Instance"); \
return OAL_STATUS_INVALID_PARAM; \
} \
} while (0)
-#define CHECK_SERVER_REGISTRATION(instance_id) \
+#define CHECK_CORRECT_SERVER_ID(server_if, server_inst) \
do { \
- if (gatt_servers[instance_id - 1].server_id < 0) {\
- BT_INFO("GATT server registeration is not done for server Instance : %d", instance_id);\
- return OAL_STATUS_INTERNAL_ERROR;\
- } \
- } while (0)
-
-#define CHECK_CORRECT_SERVER_ID(instance_id, server_if, server_inst)\
- do { \
- for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) { \
- if (gatt_servers[instance_id - 1].server_id == server_if) { \
- server_inst = instance_id; \
- goto sendevent;\
- } \
+ gatt_server_t *info; \
+ info = __gatts_find_server_instance(server_if); \
+ if (info) { \
+ server_inst = server_if; \
+ goto sendevent; \
} \
} while (0)
} \
} while (0)
+#define CHECK_CLIENT_REGISTRATION(client_id) \
+ do { \
+ if (client_id <= 0) { \
+ BT_DBG("No client registered yet...");\
+ return OAL_STATUS_INTERNAL_ERROR;\
+ } \
+ } while (0)
+
+#define CHECK_CLIENT_CONNECTION(conn_id) \
+ do { \
+ if (conn_id <= 0) {\
+ BT_ERR("No active connection");\
+ return OAL_STATUS_INTERNAL_ERROR;\
+ } \
+ } while (0)
+
+
typedef enum {
GATT_INS_DISABLED,
GATT_INS_DATA_SETTING,
} gatt_data_state;
typedef struct {
- int server_id;
+ int instance_id;
oal_uuid_t uuid;
int state;
+ gboolean cur_adv_state;
} gatt_server_t;
const char *oal_device_type[] = {
} oal_pending_gattc_req_e;
static const btgatt_interface_t * gatt_api;
-static gboolean cur_adv_state[NUM_SERVER_INST];
-static gatt_server_t gatt_servers[NUM_SERVER_INST];
-
-static int default_client_id = -1;
-static int pending_gattc_req = OAL_REQ_NONE;
+static GSList *gatt_servers = NULL; /* List of gatt_server_t */
/* Forward declarations of GATT Server callbacks */
static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid);
bool need_rsp, bool is_prep, uint8_t* value);
static void cb_gatts_response_confirmation(int status, int handle);
+static void cb_gatts_acquire_write(int fd, int conn_id, int trans_id, int attr_handle, bt_bdaddr_t*);
+static void cb_gatts_acquire_notify(int fd, int conn_id, int trans_id, int attr_handle);
+
static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda);
static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda);
/*TODO GATT Server callbacks will be implemented in subsequent patches */
static const btgatt_server_callbacks_t btgatt_server_callbacks = {
- cb_gatts_register_app,
- cb_gatts_connection,
- cb_gatts_service_added,
- cb_gatts_included_service_added,
- cb_gatts_characteristic_added,
- cb_gatts_descriptor_added,
- cb_gatts_service_started,
- cb_gatts_service_stopped,
- cb_gatts_service_deleted,
- cb_indication_confirmation,
- cb_gatts_request_read,
- cb_gatts_request_write,
- NULL, /*cb_gatts_request_exec_write,*/
- cb_gatts_response_confirmation,
- cb_gatts_listen,
- cb_gatts_multi_adv_enable,
- cb_gatts_multi_adv_update,
- cb_gatts_multi_adv_set_inst_data,
- cb_gatts_multi_adv_disable,
- cb_gatts_mtu_changed,
+ .register_server_cb = cb_gatts_register_app,
+ .connection_cb = cb_gatts_connection,
+ .service_added_cb = cb_gatts_service_added,
+ .included_service_added_cb = cb_gatts_included_service_added,
+ .characteristic_added_cb = cb_gatts_characteristic_added,
+ .descriptor_added_cb = cb_gatts_descriptor_added,
+ .service_started_cb = cb_gatts_service_started,
+ .service_stopped_cb = cb_gatts_service_stopped,
+ .service_deleted_cb = cb_gatts_service_deleted,
+ .indication_confirmation_cb = cb_indication_confirmation,
+ .request_read_cb = cb_gatts_request_read,
+ .request_write_cb = cb_gatts_request_write,
+ .request_exec_write_cb = NULL,
+ .response_confirmation_cb = cb_gatts_response_confirmation,
+ .listen_cb = cb_gatts_listen,
+ .multi_adv_enable_cb = cb_gatts_multi_adv_enable,
+ .multi_adv_update_cb = cb_gatts_multi_adv_update,
+ .multi_adv_data_cb = cb_gatts_multi_adv_set_inst_data,
+ .multi_adv_disable_cb = cb_gatts_multi_adv_disable,
+ .mtu_changed_cb = cb_gatts_mtu_changed,
#ifdef TIZEN_BT_HAL
- cb_notifcation_changed,
+ .notif_enabled_cb = cb_notifcation_changed,
#endif
+ .request_acquire_write_cb = cb_gatts_acquire_write,
+ .request_acquire_notify_cb = cb_gatts_acquire_notify
};
/* Forward declaration for GATT client callbacks */
static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid);
-static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data);
+static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, uint8_t addr_type, int rssi,
+ uint8_t *adv_data, int adv_data_len, uint8_t *scan_rsp_data, int scan_rsp_data_len);
+static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
+static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
+static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id);
+static void cb_gattc_search_complete(int conn_id, int status);
+static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
+ btgatt_gatt_id_t *char_id, int char_prop);
+static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
+ btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id);
+static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data);
+static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data);
+static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data);
+static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data);
+static void cb_gattc_register_for_notification(int conn_id, int registered, int status,
+ btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id);
+static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data);
+static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id, int inst_id);
+static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu);
/*TODO GATT CLient callbacks will be implemented in subsequent patches */
static const btgatt_client_callbacks_t btgatt_client_callbacks = {
- cb_gattc_register_app,
- cb_gattc_scan_result,
- NULL, /*cb_gattc_connection*/
- NULL, /*cb_gattc_disconnect*/
- NULL, /*cb_gattc_search_complete*/
- NULL, /*cb_gattc_search_result*/
- NULL, /*cb_gattc_get_characteristics*/
- NULL, /*cb_gattc_get_descriptor*/
- NULL, /*cb_gattc_get_included_service*/
- NULL, /*cb_gattc_register_for_notification*/
- NULL, /*cb_gattc_notify*/
- NULL, /*cb_gattc_read_characteristic*/
- NULL, /*cb_gattc_write_characteristic*/
- NULL, /*cb_gattc_read_descriptor*/
- NULL, /*cb_gattc_write_descriptor*/
- NULL, /*cb_gattc_execute_write*/
- NULL, /*cb_gattc_remote_rssi*/
- NULL, /*cb_gattc_configure_mtu_cmpl*/
+ .register_client_cb = cb_gattc_register_app,
+ .scan_result_cb = cb_gattc_scan_result,
+ .open_cb = cb_gattc_connection,
+ .close_cb = cb_gattc_disconnect,
+ .search_complete_cb = cb_gattc_search_complete,
+ .search_result_cb = cb_gattc_search_result,
+ .get_characteristic_cb = cb_gattc_get_characteristics,
+ .get_descriptor_cb = cb_gattc_get_descriptor,
+ .get_included_service_cb = NULL,
+ .register_for_notification_cb = cb_gattc_register_for_notification,
+ .notify_cb = cb_gattc_notify,
+ .service_changed_cb = cb_gattc_service_changed,
+ .read_characteristic_cb = cb_gattc_read_characteristic,
+ .write_characteristic_cb = cb_gattc_write_characteristic,
+ .read_descriptor_cb = cb_gattc_read_descriptor,
+ .write_descriptor_cb = cb_gattc_write_descriptor,
+ .execute_write_cb = NULL,
+ .read_remote_rssi_cb = NULL,
+ .configure_mtu_cb = cb_gattc_configure_mtu_cmpl,
#ifdef PLATFORM_ANDROID_HAL
- NULL, /*cb_scan_filter_cfg*/
- NULL, /*cb_scan_filter_param*/
- NULL, /*cb_scan_filter_status*/
- NULL, /*cb_congestion*/
- NULL, /*cb_batchscan_cfg_storag*/
- NULL, /*cb_batchscan_enb_disable*/
- NULL, /*cb_batchscan_reports*/
- NULL, /*cb_batchscan_threshold*/
- NULL, /*cb_track_adv_event*/
+ .scan_filter_cfg_cb = NULL,
+ .scan_filter_param_cb = NULL,
+ .scan_filter_status_cb = NULL,
+ .congestion_cb = NULL,
+ .batchscan_cfg_storage_cb = NULL,
+ .batchscan_enb_disable_cb = NULL,
+ .batchscan_reports_cb = NULL,
+ .batchscan_threshold_cb = NULL,
+ .track_adv_event_cb = NULL,
#endif
};
{
const bt_interface_t * blued_api;
int ret;
- int i = 0;
-
- for (i = 0; i < NUM_SERVER_INST; i++) {
- gatt_servers[i].server_id = -1;
- gatt_servers[i].state = GATT_INS_DISABLED;
- memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
- cur_adv_state[i] = FALSE;
- }
/* Get stack interface */
blued_api = (const bt_interface_t *) adapter_get_stack_interface();
oal_status_t gatt_disable(void)
{
- int i;
if (gatt_api) {
gatt_api->cleanup();
gatt_api = NULL;
}
- for (i = 0; i < NUM_SERVER_INST; i++) {
- gatt_servers[i].server_id = -1;
- gatt_servers[i].state = GATT_INS_DISABLED;
- memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
- }
+ g_slist_free_full(gatt_servers, g_free);
+ gatt_servers = NULL;
return OAL_STATUS_SUCCESS;
}
+static gatt_server_t *__gatts_find_server_instance(int instance_id)
+{
+ gatt_server_t *info;
+ GSList *l;
+
+ for (l = gatt_servers; l; l = g_slist_next(l)) {
+ info = l->data;
+ if (!info)
+ continue;
+ if (info->instance_id == instance_id)
+ return info;
+ }
+
+ return NULL;
+}
+
/************************************GATT Server Functions*************************************/
/*Public */
oal_status_t gatts_register(oal_uuid_t* server_uuid)
{
char str[2*BT_UUID_STRING_MAX];
int ret = OAL_STATUS_SUCCESS;
- int i;
+ GSList *l;
CHECK_OAL_GATT_ENABLED();
uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
API_TRACE("Register the server instance: UUID: [%s]", str);
- for (i = 0; i < NUM_SERVER_INST; i++) {
- if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
- if (gatt_servers[i].server_id != -1) {
- BT_ERR("This is resevered UUID for easy set up application i = %d \
- gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
+ for (l = gatt_servers; l; l = g_slist_next(l)) {
+ gatt_server_t *info = l->data;
+ if (!info)
+ continue;
+ if (memcmp(server_uuid->uuid, info->uuid.uuid, sizeof(oal_uuid_t)) == 0) {
+ if (info->instance_id != -1) {
+ BT_ERR("This is resevered UUID for easy set up application \
+ instance_id = %d", info->instance_id);
return OAL_STATUS_ALREADY_DONE;
}
}
oal_status_t gatts_unregister(int instance_id)
{
int ret = OAL_STATUS_SUCCESS;
+ gatt_server_t *info;
API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
- ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
+ info = __gatts_find_server_instance(instance_id);
+ if (!info)
+ return OAL_STATUS_INTERNAL_ERROR;
+ ret = gatt_api->server->unregister_server(instance_id);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT server unregistration failed: %d", instance_id);
return convert_to_oal_status(ret);
}
- gatt_servers[instance_id-1].server_id = -1;
- gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
-
- if (instance_id != 1 && instance_id != 2)
- memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
+ info->instance_id = -1;
+ info->state = GATT_INS_DISABLED;
+ info->cur_adv_state = FALSE;
+ if (instance_id != 1 && instance_id != 2) {
+ gatt_servers = g_slist_remove(gatt_servers, info);
+ BT_DBG("GATT Server Removed. count of gatt_servers: %d",
+ g_slist_length(gatt_servers));
+ }
return OAL_STATUS_SUCCESS;
}
oal_status_t gatts_start_listen(int instance_id, gboolean enable)
{
int ret = OAL_STATUS_SUCCESS;
- API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
+ gatt_server_t *info;
+ API_TRACE("instance_id: %d enable: %d", instance_id, enable);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
-
- ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
+ info = __gatts_find_server_instance(instance_id);
+ if (!info)
+ return OAL_STATUS_INTERNAL_ERROR;
+ ret = gatt_api->server->listen(instance_id, enable);
if (ret != BT_STATUS_SUCCESS) {
- BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
- gatt_servers[instance_id-1].server_id, status2string(ret));
+ BT_ERR("Error:Advertising %s on instance_id: %d failed \
+ with status: %s, cur_adv_state: %d",
+ enable ? "Start" : "Stop", instance_id,
+ status2string(ret), info->cur_adv_state);
return convert_to_oal_status(ret);
}
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
-
- ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
+ ret = gatt_api->server->listen(instance_id, FALSE);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
instance_id, status2string(ret));
oal_status_t gatts_multi_adv_enable(int instance_id)
{
int ret = OAL_STATUS_SUCCESS;
- API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
- gatt_servers[instance_id - 1].server_id, instance_id);
+ gatt_server_t *info;
+ API_TRACE("Start Multi advertising, instance_id: %d", instance_id);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
+ info = __gatts_find_server_instance(instance_id);
+ if (!info)
+ return OAL_STATUS_INTERNAL_ERROR;
if (gatt_api->server->multi_adv_enable == NULL)
return OAL_STATUS_NOT_SUPPORT;
return OAL_STATUS_BUSY;
}
*/
- if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
- BT_ERR("Not allowed, state: %d, instance_id: %d",
- gatt_servers[instance_id - 1].state, instance_id);
- return OAL_STATUS_ALREADY_DONE;
- }
- if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
- BT_ERR("Not allowed, state: %d, instance_id: %d",
- gatt_servers[instance_id - 1].state, instance_id);
+ if (info->state == GATT_INS_ENABLED) {
+ BT_ERR("Not allowed, state: %d, instance_id: %d", info->state, instance_id);
+ return OAL_STATUS_ALREADY_DONE;
+ } else if (info->state == GATT_INS_ENABLING) {
+ BT_ERR("Not allowed, state: %d, instance_id: %d", info->state, instance_id);
return OAL_STATUS_BUSY;
}
+ info->state = GATT_INS_ENABLING;
- gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
-
- ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
-
+ ret = gatt_api->server->multi_adv_enable(instance_id);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
instance_id, status2string(ret));
oal_status_t gatts_multi_adv_disable(int instance_id)
{
int ret = OAL_STATUS_SUCCESS;
- API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
- gatt_servers[instance_id - 1].server_id, instance_id);
+ gatt_server_t *info;
+ API_TRACE("Stop Multi advertising, instance_id: %d", instance_id);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
+ info = __gatts_find_server_instance(instance_id);
+ if (!info)
+ return OAL_STATUS_INTERNAL_ERROR;
if (gatt_api->server->multi_adv_disable == NULL)
return OAL_STATUS_NOT_SUPPORT;
- if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
- BT_ERR("Not Allowed, state: %d, instance_id: %d",
- gatt_servers[instance_id - 1].state, instance_id);
+ if (info->state != GATT_INS_ENABLED) {
+ BT_ERR("Not Allowed, state: %d, instance_id: %d", info->state, instance_id);
return OAL_STATUS_BUSY;
}
- ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
-
+ ret = gatt_api->server->multi_adv_disable(instance_id);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
instance_id, status2string(ret));
return OAL_STATUS_SUCCESS;
}
+oal_status_t gatts_set_filter_policy(int filter_policy)
+{
+ int ret = OAL_STATUS_SUCCESS;
+
+ CHECK_OAL_GATT_ENABLED();
+
+ /* send the filter_policy value to the HAL Layer */
+ ret = gatt_api->server->set_filter_policy(filter_policy);
+
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("set_filter_policy failed: %d",ret);
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
oal_status_t gatts_multi_adv_update(int instance_id,
int min_intv, int max_intv,
int adv_type, int chnl_map,
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
if (gatt_api->server->multi_adv_update == NULL)
return OAL_STATUS_NOT_SUPPORT;
- ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
+ ret = gatt_api->server->multi_adv_update(instance_id,
min_intv, max_intv,
adv_type, chnl_map,
tx_power, timeout_s);
-
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
instance_id, status2string(ret));
{
int ret = OAL_STATUS_SUCCESS;
btgatt_adv_param_setup_t adv_setup;
- API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
- gatt_servers[instance_id - 1].server_id, instance_id);
+ gatt_server_t *info;
+ API_TRACE("Set Multi advertising data, instance_id: %d", instance_id);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
+ info = __gatts_find_server_instance(instance_id);
+ if (!info)
+ return OAL_STATUS_INTERNAL_ERROR;
if (gatt_api->server->multi_adv_set_inst_data == NULL)
return OAL_STATUS_NOT_SUPPORT;
- if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
- BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
+ if (info->state >= GATT_INS_DATA_SETTING && info->state != GATT_INS_DATA_SET) {
+ BT_ERR("Not Allowed, state: %d, instance_id: %d", info->state, instance_id);
return OAL_STATUS_BUSY;
}
-
- gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
-
+ info->state = GATT_INS_DATA_SETTING;
adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
adv_setup.include_name = adv_param_setup->include_name;
adv_setup.tx_power = adv_param_setup->tx_power;
adv_setup.timeout_s = adv_param_setup->timeout_s;
- adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
- if (adv_setup.manufacturer_data_len > 0 && adv_setup.manufacturer_data != NULL) {
- BT_INFO("Manufacture data.....\n");
- PRINT_ADV_DATA(adv_setup.manufacturer_data_len, adv_setup.manufacturer_data, adv_setup.set_scan_rsp);
- }
+ adv_setup.server_if = instance_id;
- if (adv_setup.service_uuid_len > 0 && adv_setup.service_uuid != NULL) {
- BT_INFO("Service uuid.....\n");
- PRINT_ADV_DATA(adv_setup.service_uuid_len, adv_setup.service_uuid, FALSE);
+ ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
+ info->state = GATT_INS_DISABLED;
+ return convert_to_oal_status(ret);
}
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ bdstr_t bdstr;
+ API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
- ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_SERVER_INSTANCE(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
+
+ API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
+ ret = gatt_api->server->disconnect(instance_id, (bt_bdaddr_t *) device_address, conn_id);
if (ret != BT_STATUS_SUCCESS) {
- BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
- gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
+ BT_ERR("GATT Server disconnect failed: %s", status2string(ret));
return convert_to_oal_status(ret);
}
return OAL_STATUS_SUCCESS;
}
+
/************************************GATT Server Functions*************************************/
/*Server Callbacks*/
static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
{
- int i;
char str[2*BT_UUID_STRING_MAX];
uuid_to_stringname((service_uuid_t*)uuid, str);
event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
- BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
- BT_INFO("UUID: [%s]", str);
+ BT_INFO("BTGATT SERVER REGISTER APP CB, UUID:%s, status:%d, server_if:%d",
+ str, status, server_if);
- for (i = 0; i < NUM_SERVER_INST; i++) {
- if (gatt_servers[i].server_id == -1) {
- BT_INFO("Server Instance registered with stack [%d]", i+1);
- gatt_servers[i].server_id = server_if;
- event->server_inst = i+1;
- memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
- memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
- break;
- }
- }
+ gatt_server_t *info = g_malloc0(sizeof(gatt_server_t));
+ info->instance_id = server_if;
+ memcpy(info->uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
+ gatt_servers = g_slist_append(gatt_servers, info);
+ BT_DBG("GATT Server Added. count of gatt_servers: %d", g_slist_length(gatt_servers));
+
+ event->server_inst = server_if;
+ memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
}
static void cb_gatts_listen(int status, int server_if)
{
- gboolean prev_state[NUM_SERVER_INST];
- gboolean new_state;
+ gboolean prev_state;
+ gboolean new_state = FALSE;
event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
- int instance_id;
-
- for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
- if (gatt_servers[instance_id - 1].server_id == server_if) {
- event->server_inst = instance_id;
+ GSList *l;
+
+ for (l = gatt_servers; l; l = g_slist_next(l)) {
+ gatt_server_t *info = l->data;
+ if (!info)
+ continue;
+ if (info->instance_id == server_if) {
+ event->server_inst = server_if;
+ prev_state = info->cur_adv_state;
+ new_state = (status == BT_STATUS_SUCCESS) ? !prev_state : prev_state;
+ info->cur_adv_state = new_state;
break;
- } else {
- BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
}
}
- if (event->server_inst > 0) {
- prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
- new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
- cur_adv_state[event->server_inst - 1] = new_state;
- } else {
- BT_ERR("Invalid Callback...");
- return;
- }
- BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
+ BT_INFO("Adv State of server instance %d, new_state: %d", server_if, new_state);
if (TRUE == new_state)
send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
- int instance_id;
+ GSList *l;
if (status != BT_STATUS_SUCCESS)
BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
- for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
- if (gatt_servers[instance_id - 1].server_id == server_if) {
- event->server_inst = instance_id;
- gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
+ for (l = gatt_servers; l; l = g_slist_next(l)) {
+ gatt_server_t *info = l->data;
+ if (!info)
+ continue;
+ if (info->instance_id == server_if) {
+ event->server_inst = server_if;
+ info->state = GATT_INS_ENABLED;
goto sendevent;
}
}
- BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->server_inst = -1;
sendevent:
event->status = convert_to_oal_status(status);
{
BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
- int instance_id;
+ GSList *l;
if (status != BT_STATUS_SUCCESS)
BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
- for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
- if (gatt_servers[instance_id - 1].server_id == server_if) {
- event->server_inst = instance_id;
- gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
+ for (l = gatt_servers; l; l = g_slist_next(l)) {
+ gatt_server_t *info = l->data;
+ if (!info)
+ continue;
+ if (info->instance_id == server_if) {
+ event->server_inst = server_if;
+ info->state = GATT_INS_DISABLED;
goto sendevent;
}
}
- BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->server_inst = -1;
sendevent:
event->status = convert_to_oal_status(status);
{
BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
- int instance_id;
+ GSList *l;
if (status != BT_STATUS_SUCCESS)
BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
- for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
- if (gatt_servers[instance_id - 1].server_id == server_if) {
- event->server_inst = instance_id;
+ for (l = gatt_servers; l; l = g_slist_next(l)) {
+ gatt_server_t *info = l->data;
+ if (!info)
+ continue;
+ if (info->instance_id == server_if) {
+ event->server_inst = server_if;
goto sendevent;
}
}
- BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->server_inst = -1;
sendevent:
event->status = convert_to_oal_status(status);
{
BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
- int instance_id;
+ GSList *l;
if (status != BT_STATUS_SUCCESS)
BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
- for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
- if (gatt_servers[instance_id - 1].server_id == server_if) {
- event->server_inst = instance_id;
- gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
+ for (l = gatt_servers; l; l = g_slist_next(l)) {
+ gatt_server_t *info = l->data;
+ if (!info)
+ continue;
+ if (info->instance_id == server_if) {
+ event->server_inst = server_if;
+ info->state = GATT_INS_DATA_SET;
goto sendevent;
}
}
- BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->server_inst = -1;
sendevent:
event->status = convert_to_oal_status(status);
ret = gatt_api->server->get_att_mtu(conn_id, mtu);
if (ret != BT_STATUS_SUCCESS) {
- BT_ERR("GATT MTU Size failed, status: %d", status2string(ret));
+ BT_ERR("GATT MTU Size failed, status: %s", status2string(ret));
return convert_to_oal_status(ret);
}
BT_INFO("Current ATT MTU Size: %d", *mtu);
return OAL_STATUS_SUCCESS;
}
+oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
+ int status, int fd, int mtu , void * fdlist)
+{
+ int ret = OAL_STATUS_SUCCESS;
+
+ API_TRACE("Server Send Response : ConnId = %d, TransId = %d, %d", conn_id, trans_id, fd);
+ CHECK_OAL_GATT_ENABLED();
+
+ ret = gatt_api->server->send_response_acquire(conn_id, trans_id, status, fd, mtu, fdlist);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
int num_handles)
{
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
-
- if (gatt_servers[instance_id - 1].server_id < 0) {
- BT_INFO("GATT server registeration is not done for server Instance : %d", instance_id);
- return gatts_register(&gatt_servers[instance_id - 1].uuid);
- }
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
if (gatt_serv_id != NULL) {
uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
return OAL_STATUS_INVALID_PARAM;
}
- ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
-
+ ret = gatt_api->server->add_service(instance_id, &btgatt_srvc_id, num_handles);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server add service failed: %s", status2string(ret));
return convert_to_oal_status(ret);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
- CHECK_SERVER_REGISTRATION(instance_id);
-
- ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
+ ret = gatt_api->server->add_included_service(instance_id, serv_handle, incl_handle);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
return convert_to_oal_status(ret);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
-
- CHECK_SERVER_REGISTRATION(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
if (charc_uuid != NULL) {
uuid_to_stringname(charc_uuid, str);
API_TRACE("uuid: [%s]", str);
}
- ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
+ ret = gatt_api->server->add_characteristic(instance_id,
serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
-
- CHECK_SERVER_REGISTRATION(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
if (desc_uuid != NULL) {
uuid_to_stringname(desc_uuid, str);
API_TRACE("uuid: [%s]", str);
}
- ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
+ ret = gatt_api->server->add_descriptor(instance_id,
serv_handle, (bt_uuid_t*)desc_uuid, permsn);
-
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
return convert_to_oal_status(ret);
CHECK_OAL_GATT_ENABLED();
CHECK_SERVER_INSTANCE(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
- CHECK_SERVER_REGISTRATION(instance_id);
-
- ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
-
+ ret = gatt_api->server->start_service(instance_id, svc_handle, transport);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
return convert_to_oal_status(ret);
return OAL_STATUS_SUCCESS;
}
-oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
+oal_status_t gatts_stop_service(int instance_id, int srv_hdl)
{
int ret = OAL_STATUS_SUCCESS;
- API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
+ API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", instance_id, srv_hdl);
CHECK_OAL_GATT_ENABLED();
- CHECK_SERVER_INSTANCE(ins_id);
- CHECK_SERVER_REGISTRATION(ins_id);
+ CHECK_SERVER_INSTANCE(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
- ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
+ ret = gatt_api->server->stop_service(instance_id, srv_hdl);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
return convert_to_oal_status(ret);
return OAL_STATUS_SUCCESS;
}
-oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
+oal_status_t gatts_delete_service(int instance_id, int srv_hdl)
{
int ret = OAL_STATUS_SUCCESS;
- API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
+ API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", instance_id, srv_hdl);
CHECK_OAL_GATT_ENABLED();
- CHECK_SERVER_INSTANCE(ins_id);
-
- CHECK_SERVER_REGISTRATION(ins_id);
+ CHECK_SERVER_INSTANCE(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
- ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
+ ret = gatt_api->server->delete_service(instance_id, srv_hdl);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
return convert_to_oal_status(ret);
return OAL_STATUS_SUCCESS;
}
-oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
+oal_status_t gatts_send_indication(int instance_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
{
int ret = OAL_STATUS_SUCCESS;
API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
- ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
+ instance_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
CHECK_OAL_GATT_ENABLED();
- CHECK_SERVER_INSTANCE(ins_id);
-
- CHECK_SERVER_REGISTRATION(ins_id);
+ CHECK_SERVER_INSTANCE(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
if (value == NULL || len == 0) {
BT_ERR("GATT Server attribute value is empty");
return OAL_STATUS_INVALID_PARAM;
}
- ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
+ ret = gatt_api->server->send_indication(instance_id,
attr_hndl, conn_id, len, confirm, value);
-
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
return convert_to_oal_status(ret);
return OAL_STATUS_SUCCESS;
}
-oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
+oal_status_t gatts_update_att_value(int instance_id, oal_gatt_value_t *value)
{
int ret = OAL_STATUS_SUCCESS;
- API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
- ins_id, value->handle, value->len);
-
CHECK_OAL_GATT_ENABLED();
- CHECK_SERVER_INSTANCE(ins_id);
-
- CHECK_SERVER_REGISTRATION(ins_id);
+ CHECK_SERVER_INSTANCE(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
if (value == NULL || value->len == 0) {
BT_ERR("GATT Server attribute value is empty");
return OAL_STATUS_INVALID_PARAM;
}
- ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
- (int)value->handle, (int)value->len, (char*)value->value);
+ API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
+ instance_id, value->handle, value->len);
+ ret = gatt_api->server->update_att_value(instance_id,
+ (int)value->handle, (int)value->len, (char*)value->value);
if (ret != BT_STATUS_SUCCESS) {
BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
return convert_to_oal_status(ret);
static void cb_gatts_service_added(int status, int server_if,
btgatt_srvc_id_t *psrvc_id, int srvc_handle)
{
- int instance_id;
-
BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
- CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
+ CHECK_CORRECT_SERVER_ID(server_if, event->gatt_srvc_stat.server_inst);
BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->gatt_srvc_stat.server_inst = -1;
int srvc_handle,
int incl_srvc_handle)
{
- int ins_id ;
BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
status, srvc_handle, incl_srvc_handle);
event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
- CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
+ CHECK_CORRECT_SERVER_ID(server_if, event->gatt_srvc_stat.server_inst);
BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->gatt_srvc_stat.server_inst = -1;
static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
int srvc_handle, int char_handle)
{
- int Ins_id ;
-
BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
status, srvc_handle, char_handle);
event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
- CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
+ CHECK_CORRECT_SERVER_ID(server_if, event->gatt_srvc_stat.server_inst);
BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->gatt_srvc_stat.server_inst = -1;
bt_uuid_t *descr_id, int srvc_handle,
int descr_handle)
{
- int Ins_id ;
BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
status, srvc_handle, descr_handle);
event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
- CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
+ CHECK_CORRECT_SERVER_ID(server_if, event->gatt_srvc_stat.server_inst);
BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->gatt_srvc_stat.server_inst = -1;
static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
{
- int Ins_id ;
BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
- CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
+ CHECK_CORRECT_SERVER_ID(server_if, event->server_inst);
BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->server_inst = -1;
static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
{
- int ins_id ;
BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
- CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
+ CHECK_CORRECT_SERVER_ID(server_if, event->server_inst);
BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->server_inst = -1;
static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
{
- int ins_id;
BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
- CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
+ CHECK_CORRECT_SERVER_ID(server_if, event->server_inst);
BT_ERR("Invalid Interface, srv_if: %d", server_if);
event->server_inst = -1;
static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
{
- int ins_id ;
+ GSList *l;
oal_event_t event_type;
BT_INFO("BTGATT SERVER CONNECTION connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
- for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
- if ((gatt_servers[ins_id - 1].server_id == server_if) &&
- (gatt_servers[ins_id - 1].state == GATT_INS_ENABLED)) {
- event->server_inst = ins_id;
- break;
- } else {
- BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
+ if (connected == TRUE) {
+ for (l = gatt_servers; l; l = g_slist_next(l)) {
+ gatt_server_t *info = l->data;
+ if (!info)
+ continue;
+ if (info->instance_id == server_if) {
+ event->server_inst = server_if;
+ break;
+ }
}
- }
- if (ins_id == NUM_SERVER_INST+1) {
- BT_WARN("Incorrect Server Interface received: %d\n", server_if);
- g_free(event);
- return;
+ } else {
+ /* server_inst is not required in disconnected case */
}
memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
event->conn_id = conn_id;
event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
+ event->status = OAL_STATUS_SUCCESS;
send_event(event_type, event, sizeof(event_gatts_conn_t));
}
send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
}
+static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
+
+{
+ BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
+
+ event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
+
+ event->attr_trans.attr_handle = attr_handle;
+ event->attr_trans.conn_id = conn_id;
+ event->attr_trans.trans_id = trans_id;
+ event->mtu = mtu;
+ memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
+
+ send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
+}
+
+static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
+{
+ BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
+
+ event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
+
+ event->attr_trans.attr_handle = attr_handle;
+ event->attr_trans.conn_id = conn_id;
+ event->attr_trans.trans_id = trans_id;
+ event->mtu = mtu;
+
+ send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
+
+}
+
static void cb_gatts_response_confirmation(int status, int handle)
{
BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
/* Check if GATT client registered for Default GATT client UUID */
uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
- if (!strncasecmp(DEFAULT_GATT_CLIENT_UUID,
- uuid_str, strlen(DEFAULT_GATT_CLIENT_UUID))) {
- default_client_id = clientIf;
- switch (pending_gattc_req) {
- case OAL_REQ_LE_SCAN:
- if (0 != status) {
- default_client_id = -1;
- pending_gattc_req = OAL_REQ_NONE;
- BT_ERR("Default client app creation failed");
- send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
- break;
- }
-
- if (OAL_STATUS_SUCCESS != gattc_start_le_discovery()) {
- BT_ERR("Error:Start LE Discovery failed");
- send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
- }
- break;
- default:
- BT_ERR("Unknown pending request: %d", pending_gattc_req);
- }
-
- /* Return from here, no need to send GATTC_REGISTRATION event */
- return;
- }
- BT_INFO("BTGATT CLIENT REGISTER APP CB, status:%d, clientIf:%d", status, clientIf);
+ BT_INFO("GATT CLIENT REGISTER APP CB, status:%d, clientIf:%d, %s", status, clientIf, uuid_str);
event = g_new0(event_gattc_register_t, 1);
event->client_if = clientIf;
event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
- send_event_no_trace(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
+ send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
}
-static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
+static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, uint8_t addr_type, int rssi,
+ uint8_t *adv_data, int adv_data_len, uint8_t *scan_rsp_data, int scan_rsp_data_len)
{
event_ble_scan_result_info *event;
event = g_new0(event_ble_scan_result_info, 1);
+ event->addr_type = addr_type;
event->rssi = rssi;
memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
+ event->adv_data_len = adv_data_len;
+ memcpy(event->scan_rsp_data, scan_rsp_data, BLE_ADV_DATA_LENGTH);
+ event->scan_rsp_data_len = scan_rsp_data_len;
send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
}
-/* Register default gatt client to be used in LE scan etc. */
-static oal_status_t __register_default_gatt_client(void)
+static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
{
- bt_uuid_t uuid;
- int ret;
+ event_gattc_conn_t *event;
+ BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
+ status, client_if, conn_id);
- API_TRACE("GATT client register");
- CHECK_OAL_GATT_ENABLED();
+ event = g_new0(event_gattc_conn_t, 1);
+ memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
+ event->client_if = client_if;
- if (default_client_id >= 0) {
- BT_ERR("Client Already registered");
- return OAL_STATUS_ALREADY_DONE;
+ if (BT_STATUS_SUCCESS != status) {
+ event->status = OAL_STATUS_INTERNAL_ERROR;
+ BT_ERR("gattc connection Error: %d", status);
+ } else {
+ event->conn_id = conn_id;
+ event->status = OAL_STATUS_SUCCESS;
}
- string_to_uuid(DEFAULT_GATT_CLIENT_UUID, (service_uuid_t *)&uuid);
- ret = gatt_api->client->register_client(&uuid);
- if (ret != BT_STATUS_SUCCESS) {
- BT_ERR("GATT client register failed: %s", status2string(ret));
- return convert_to_oal_status(ret);
- }
+ send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
+ sizeof(*event), (bt_address_t *)bda);
+}
- return OAL_STATUS_SUCCESS;
+
+static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
+{
+ event_gattc_conn_t *event;
+ BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
+ status, client_if, conn_id);
+ event = g_new0(event_gattc_conn_t, 1);
+ event->status = convert_to_oal_status(status);
+ event->client_if = client_if;
+ event->conn_id = conn_id;
+ memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
+ send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
+ sizeof(*event), (bt_address_t *)bda);
}
-oal_status_t gattc_start_le_discovery(void)
+static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
{
- int ret;
+ char uuid_str[2*BT_UUID_STRING_MAX];
- API_TRACE("BTGATT CLIENT SCAN START");
- CHECK_OAL_GATT_ENABLED();
+ uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
+ BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
+ uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
- if (default_client_id < 0) {
- if (pending_gattc_req != OAL_REQ_NONE) {
- BT_ERR("Another request: %d already in progress", pending_gattc_req);
- return OAL_STATUS_INTERNAL_ERROR;
- }
+ event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
+ event->conn_status.status = OAL_STATUS_SUCCESS;
+ event->conn_status.conn_id = conn_id;
+ memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
- pending_gattc_req = OAL_REQ_LE_SCAN;
- ret = __register_default_gatt_client();
- if (OAL_STATUS_SUCCESS != ret) {
- BT_ERR("__register_default_gatt_client failed");
- pending_gattc_req = OAL_REQ_NONE;
- return OAL_STATUS_INTERNAL_ERROR;
- }
+ send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
+}
- return OAL_STATUS_SUCCESS;
- }
+static void cb_gattc_search_complete(int conn_id, int status)
+{
+ BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
+ status, conn_id);
- ret = gatt_api->client->scan(default_client_id, true);
- if (ret != BT_STATUS_SUCCESS) {
- BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
- return convert_to_oal_status(ret);
- }
+ event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
+ event->conn_id = conn_id;
+ event->status = convert_to_oal_status(status);
- send_event(OAL_EVENT_BLE_DISCOVERY_STARTED, NULL, 0);
- return OAL_STATUS_SUCCESS;
+ send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
}
-oal_status_t gattc_stop_le_discovery(void)
+
+static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
+ btgatt_gatt_id_t *char_id, int char_prop)
{
- int ret;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ char str[50];
+
+ BT_DBG("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
+ uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
+ BT_DBG("Service=> [%s], Inst_id [%u], Type [%s]",
+ uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
+
+ event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
+ event->conn_status.conn_id = conn_id;
+ event->conn_status.status = convert_to_oal_status(status);
+ memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
+
+ if (status == 0) {
+ uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
+ BT_INFO("Charac => [%s], Inst_id [%u], Prop [%s]",
+ uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
+ event->char_prop = char_prop;
+ memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
+ }
+ send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
+}
- API_TRACE("Scan is stopped");
- CHECK_OAL_GATT_ENABLED();
- ret = gatt_api->client->scan(default_client_id, false);
- if (ret != BT_STATUS_SUCCESS) {
- BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
- return convert_to_oal_status(ret);
+
+static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id)
+{
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ char uuid_str3[2*BT_UUID_STRING_MAX];
+ BT_DBG("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
+ uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
+ BT_DBG("Service=> [%s], Inst_id [%u], Type [%s]",
+ uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
+ BT_DBG("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
+
+ event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
+ event->conn_status.conn_id = conn_id;
+ event->conn_status.status = convert_to_oal_status(status);
+ memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
+ memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
+
+ if (status == 0) {
+ uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
+ BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, descr_id->inst_id);
+ memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
}
+ send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
+}
- send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
- return OAL_STATUS_SUCCESS;
+static void cb_gattc_register_for_notification(int conn_id, int registered, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id)
+{
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ BT_INFO("BTGATT Client Register For Notification Callback, conn_id:%d, status:%d, registered: %s",
+ conn_id, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
+ uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
+ BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
+ BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
+
+ event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
+ oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
+ event->conn_id = conn_id;
+ event->status = convert_to_oal_status(status);
+ memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
+ memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
+
+ send_event(event_type, event, sizeof(*event));
}
-oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
+static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
{
- int ret;
+ bdstr_t bdstr;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+
+ BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
+ BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
+ bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
+
+ uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
+ uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
+
+ BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
+ uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
+ BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
+
+ if (p_data->len > 0) {
+ char *data = NULL;
+ data = g_malloc(3*p_data->len+1);
+ if (!data) {
+ BT_ERR("memory allocation failed");
+ return;
+ }
- API_TRACE("Scan is stopped");
- CHECK_OAL_GATT_ENABLED();
+ convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
+ BT_INFO("Notified Data: [%s]", data);
-#ifdef TIZEN_BT_HAL
- ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
- if (ret != BT_STATUS_SUCCESS) {
- BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
- return convert_to_oal_status(ret);
- }
-#else
- ret = gatt_api->client->set_scan_parameters(itv, win);
- if (ret != BT_STATUS_SUCCESS) {
- BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
- return convert_to_oal_status(ret);
- }
-#endif
+ event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
+ memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
+ event->is_notify = p_data->is_notify;
+ event->data_len = p_data->len;
+ memcpy(event->data, p_data->value, event->data_len);
+ memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
+ memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
- return OAL_STATUS_SUCCESS;
+ send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
+ g_free(data);
+ }
}
+
+static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id, int inst_id)
+{
+ event_gattc_service_changed_data *event = g_new0(event_gattc_service_changed_data, 1);
+
+ memcpy(event->address.addr, bd_addr->address, 6);
+ event->change_type = change_type;
+ memcpy(event->uuid.uuid, uuid, sizeof(event->uuid.uuid));
+ event->conn_id = conn_id;
+ event->inst_id = inst_id;
+
+ send_event_bda_trace(OAL_EVENT_GATTC_SERVICE_CHANGED_IND, event, sizeof(*event), (bt_address_t *)bd_addr);
+}
+
+static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
+{
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
+
+ event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
+ event->uuid_status.conn_status.conn_id = conn_id;
+ event->uuid_status.conn_status.status = convert_to_oal_status(status);
+ event->value_type = p_data->value_type;
+ memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
+ memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
+ if (status == 0) {
+ uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
+ uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
+ BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
+ p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
+ BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
+ BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
+ if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
+ event->data_len = p_data->value.len;
+ memcpy(&(event->data), &(p_data->value.value), event->data_len);
+ }
+ }
+ send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
+}
+
+static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
+{
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
+
+ event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
+ event->conn_status.conn_id = conn_id;
+ event->conn_status.status = convert_to_oal_status(status);
+ memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
+ memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
+ if (status == 0) {
+ uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
+ uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
+ BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
+ p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
+ BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
+ }
+ send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
+}
+
+static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
+{
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ char uuid_str3[2*BT_UUID_STRING_MAX];
+ BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
+
+ event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
+ event->conn_status.conn_id = conn_id;
+ event->conn_status.status = convert_to_oal_status(status);
+ memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
+ memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
+ memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
+ if (status == 0) {
+ uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
+ uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
+ uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
+ BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
+ p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
+ BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
+ BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
+ }
+ send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
+}
+
+
+
+static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
+{
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ char uuid_str3[2*BT_UUID_STRING_MAX];
+ BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
+
+ event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
+ event->uuid_status.conn_status.conn_id = conn_id;
+ event->uuid_status.conn_status.status = convert_to_oal_status(status);
+ event->value_type = p_data->value_type;
+ memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
+ memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
+ memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
+
+ if (status == 0) {
+ uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
+ uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
+ uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
+ BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
+ p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
+ BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
+ BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
+ BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
+ if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
+ char *data = NULL;
+ data = g_malloc(3*p_data->value.len+1);
+ if (!data) {
+ BT_ERR("memory allocation failed");
+ g_free(event);
+ return;
+ }
+ convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
+ BT_DBG("Read Data: [%s]", data);
+ event->data_len = p_data->value.len;
+ memcpy(&(event->data), &(p_data->value.value), event->data_len);
+ g_free(data);
+ }
+ }
+ send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
+}
+
+oal_status_t gattc_start_le_discovery(int client_id)
+{
+
+ int ret = OAL_STATUS_SUCCESS;
+
+ API_TRACE("BTGATT CLIENT SCAN START");
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_REGISTRATION(client_id);
+
+ ret = gatt_api->client->scan(client_id, 1);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_stop_le_discovery(int client_id)
+{
+
+ int ret = OAL_STATUS_SUCCESS;
+
+ API_TRACE("Scan is stopped");
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_REGISTRATION(client_id);
+ ret = gatt_api->client->scan(client_id, 0);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
+{
+ int ret;
+
+ API_TRACE("Scan is stopped");
+ CHECK_OAL_GATT_ENABLED();
+
+#ifdef TIZEN_BT_HAL
+ ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+#else
+ ret = gatt_api->client->set_scan_parameters(itv, win);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+#endif
+
+ return OAL_STATUS_SUCCESS;
+}
+
+static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu)
+{
+ event_gattc_mtu_configured_t *event;
+ BT_INFO("BTGATT Client configure mtu complete Callback, conn_id: %d, status: %d, mtu: %d",
+ conn_id, status, mtu);
+ event = g_new0(event_gattc_mtu_configured_t, 1);
+ event->conn_id = conn_id;
+ event->mtu = mtu;
+ event->status = convert_to_oal_status(status);
+ send_event(OAL_EVENT_GATTC_MTU_EXCHANGE_COMPLETED, event, sizeof(*event));
+}
+
/************************************ GATT Client ***********************************/
+oal_status_t gattc_register(oal_uuid_t* client_uuid)
+{
+
+ char str[2*BT_UUID_STRING_MAX];
+ int ret = OAL_STATUS_SUCCESS;
+
+ CHECK_OAL_GATT_ENABLED();
+ uuid_to_stringname(client_uuid, str);
+ API_TRACE("uuid: [%s]", str);
+ /* We will perform actual registration in cb_gattc_register_app callback */
+ ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client register failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_deregister(int client_id)
+{
+ int ret = OAL_STATUS_SUCCESS;
+
+ API_TRACE("GATT client deregister");
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_REGISTRATION(client_id);
+
+ ret = gatt_api->client->unregister_client(client_id);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client deregister failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ bdstr_t bdstr;
+
+ OAL_CHECK_PARAMETER(device_address, return);
+ API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_REGISTRATION(client_id);
+
+ /* Handle the actual connection in cb_gattc_connection callback */
+ ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client connect failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
+{
+
+ int ret = OAL_STATUS_SUCCESS;
+ bdstr_t bdstr;
+
+ OAL_CHECK_PARAMETER(device_address, return);
+ API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_REGISTRATION(client_id);
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ /* Handle actual disconnection in callback */
+ ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client disconnect failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+
+oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str[2*BT_UUID_STRING_MAX];
+
+ if (service_uuid) {
+ uuid_to_stringname(service_uuid, uuid_str);
+ API_TRACE("Client Service Search UUID: [%s]", uuid_str);
+ } else
+ API_TRACE("Client Service Search All");
+
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+ ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
+
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client service search failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str[2*BT_UUID_STRING_MAX];
+
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
+ API_TRACE("Client Get Characteristic [%s]", uuid_str);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+ ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
+ (btgatt_gatt_id_t *)char_id);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
+ oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+ ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
+ (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_register_for_notification(int conn_id, bt_address_t * address,
+ oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ bdstr_t bdstr;
+
+ OAL_CHECK_PARAMETER(address, return);
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ ret = gatt_api->client->register_for_notification(conn_id, (bt_bdaddr_t *)address, (btgatt_srvc_id_t *)srvc_id, (btgatt_gatt_id_t *)char_id);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client register notification failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_deregister_for_notification(int conn_id, bt_address_t * address,
+ oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ bdstr_t bdstr;
+
+ OAL_CHECK_PARAMETER(address, return);
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ ret = gatt_api->client->deregister_for_notification(conn_id, (bt_bdaddr_t *)address, (btgatt_srvc_id_t *)srvc_id, (btgatt_gatt_id_t *)char_id);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+
+oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
+ oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
+ (btgatt_gatt_id_t *)char_id, auth_req);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
+ oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ char uuid_str3[2*BT_UUID_STRING_MAX];
+
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ OAL_CHECK_PARAMETER(desc_id, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ uuid_to_stringname(&(desc_id->uuid), uuid_str3);
+ API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
+ uuid_str1, uuid_str2, uuid_str3);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
+ (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
+ oal_gatt_id_t *char_id, int *fd, int *mtu)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
+ (btgatt_gatt_id_t *)char_id, fd, mtu);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
+ oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
+ (btgatt_gatt_id_t *)char_id, auth_req, fd, mtu);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
+ oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
+ int len, oal_gatt_auth_req_t auth_req, char* data)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ OAL_CHECK_PARAMETER(data, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
+ (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
+ oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
+ oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ char uuid_str3[2*BT_UUID_STRING_MAX];
+ OAL_CHECK_PARAMETER(srvc_id, return);
+ OAL_CHECK_PARAMETER(char_id, return);
+ OAL_CHECK_PARAMETER(desc_id, return);
+ OAL_CHECK_PARAMETER(data, return);
+ uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
+ uuid_to_stringname(&(char_id->uuid), uuid_str2);
+ uuid_to_stringname(&(desc_id->uuid), uuid_str3);
+ API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
+ uuid_str1, uuid_str2, uuid_str3);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
+ (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
+{
+ int ret;
+ bdstr_t bdstr;
+
+ OAL_CHECK_PARAMETER(address, return);
+ API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
+ CHECK_OAL_GATT_ENABLED();
+
+ BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
+ ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("error: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_unregister_scan_filter(int slot_id)
+{
+ int ret;
+ int client_if = 0;
+
+ API_TRACE("");
+ CHECK_OAL_GATT_ENABLED();
+
+ BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
+
+ ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("error: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_enable_scan_filter(int client_if)
+{
+ int ret;
+
+ API_TRACE("");
+ CHECK_OAL_GATT_ENABLED();
+
+ BT_INFO("Enable Scan filter. Client If: %d", client_if);
+
+ ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("error: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_disable_scan_filter(int client_if)
+{
+ int ret;
+
+ API_TRACE("");
+ CHECK_OAL_GATT_ENABLED();
+
+ BT_INFO("Disable Scan filter. Client If: %d", client_if);
+
+ ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("error: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
+{
+ int ret;
+ int client_info = 0;
+ int action = 0;
+ int company_id = 0;
+ int company_id_mask = 0;
+ int address_type = 0;
+ int feature_selection = 0;
+
+ oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
+ .filt_logic_type = 1,
+ .rssi_high_thres = -127,
+ .rssi_low_thres = -127,
+ .dely_mode = 0,
+ .found_timeout = 0,
+ .lost_timeout = 0,
+ .found_timeout_cnt = 0
+ };
+
+ OAL_CHECK_PARAMETER(filter_data, return);
+ API_TRACE();
+ CHECK_OAL_GATT_ENABLED();
+
+ if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
+ bdstr_t bdstr;
+ BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
+ BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
+ ret = gatt_api->client->scan_filter_add_remove(client_info,
+ action,
+ OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
+ filter_data->slot_id,
+ company_id,
+ company_id_mask,
+ NULL,
+ NULL,
+ (bt_bdaddr_t*)filter_data->device_address,
+ address_type,
+ 0,
+ NULL,
+ 0,
+ NULL
+ );
+ if (ret != BT_STATUS_SUCCESS){
+ BT_ERR("error: %s", status2string(ret));
+ BT_INFO("unregistering already set filter features.");
+ gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
+ return convert_to_oal_status(ret);
+ }
+
+ feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
+ }
+ if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
+ ret = gatt_api->client->scan_filter_add_remove(client_info,
+ action,
+ OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
+ filter_data->slot_id,
+ company_id,
+ company_id_mask,
+ NULL,
+ NULL,
+ NULL,
+ address_type,
+ 0,
+ filter_data->device_name, // device_name as p_data in HAL
+ 0,
+ NULL
+ );
+ if (ret != BT_STATUS_SUCCESS){
+ BT_ERR("error: %s", status2string(ret));
+ BT_INFO("unregistering already set filter features.");
+ gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
+ return convert_to_oal_status(ret);
+ }
+
+ feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
+ }
+ if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
+ BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+
+ uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
+ uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
+
+ BT_INFO("Service UUID is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
+ ret = gatt_api->client->scan_filter_add_remove(client_info,
+ action,
+ OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
+ filter_data->slot_id,
+ company_id,
+ company_id_mask,
+ (bt_uuid_t*)filter_data->service_uuid,
+ (bt_uuid_t*)filter_data->service_uuid_mask,
+ NULL,
+ address_type,
+ filter_data->service_uuid_len, // service_uuid_len as data_len in HAL
+ NULL,
+ filter_data->service_uuid_mask_len,
+ NULL
+ );
+ if (ret != BT_STATUS_SUCCESS){
+ BT_ERR("error: %s", status2string(ret));
+ BT_INFO("unregistering already set filter features.");
+ gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
+ return convert_to_oal_status(ret);
+ }
+
+ feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
+ }
+ if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
+ BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
+ char uuid_str1[2*BT_UUID_STRING_MAX];
+ char uuid_str2[2*BT_UUID_STRING_MAX];
+ uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
+ uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
+ BT_INFO("Service Solicitation UUID is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
+ ret = gatt_api->client->scan_filter_add_remove(client_info,
+ action,
+ OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
+ filter_data->slot_id,
+ company_id,
+ company_id_mask,
+ (bt_uuid_t*)filter_data->service_solicitation_uuid,
+ (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
+ NULL,
+ address_type,
+ filter_data->service_solicitation_uuid_len, // service_solicitation_uuid_len as data_len in HAL
+ NULL,
+ filter_data->service_solicitation_uuid_mask_len,
+ NULL
+ );
+ if (ret != BT_STATUS_SUCCESS){
+ BT_ERR("error: %s", status2string(ret));
+ BT_INFO("unregistering already set filter features.");
+ gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
+ return convert_to_oal_status(ret);
+ }
+
+ feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
+ }
+ if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
+ ret = gatt_api->client->scan_filter_add_remove(client_info,
+ action,
+ OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
+ filter_data->slot_id,
+ company_id,
+ company_id_mask,
+ NULL,
+ NULL,
+ NULL,
+ address_type,
+ filter_data->service_data_len, //service_data_len as data_len in HAL
+ (char*)filter_data->service_data,
+ filter_data->service_data_mask_len,
+ (char*)filter_data->service_data_mask
+ );
+ if (ret != BT_STATUS_SUCCESS){
+ BT_ERR("error: %s", status2string(ret));
+ BT_INFO("unregistering already set filter features.");
+ gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
+ return convert_to_oal_status(ret);
+ }
+
+ feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
+ }
+ if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
+ ret = gatt_api->client->scan_filter_add_remove(client_info,
+ action,
+ OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
+ filter_data->slot_id,
+ filter_data->manufacturer_id,
+ company_id_mask,
+ NULL,
+ NULL,
+ NULL,
+ address_type,
+ filter_data->manufacturer_data_len, //manufacturer_data_len as data_len in HAL
+ (char*)filter_data->manufacturer_data,
+ filter_data->manufacturer_data_mask_len,
+ (char*)filter_data->manufacturer_data_mask
+ );
+ feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
+ if (ret != BT_STATUS_SUCCESS){
+ BT_ERR("error: %s", status2string(ret));
+ BT_INFO("unregistering already set filter features.");
+ gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
+ return convert_to_oal_status(ret);
+ }
+
+ feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
+ }
+
+ BT_DBG("Filter selection 0x%.2x", feature_selection);
+
+ ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
+ scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
+ scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
+ scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
+ scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
+ if (ret != BT_STATUS_SUCCESS){
+ BT_ERR("error: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
+oal_status_t gattc_configure_mtu(int conn_id, int mtu)
+{
+ int ret;
+
+ API_TRACE("Configure MTU Size: [%d]", mtu);
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_CLIENT_CONNECTION(conn_id);
+
+ /* To prevent crash in case other libraries not support this api */
+ if (gatt_api->client->configure_mtu == NULL) {
+ BT_WARN("configure_mtu is NULL");
+ return OAL_STATUS_NOT_SUPPORT;
+ }
+
+ ret = gatt_api->client->configure_mtu(conn_id, mtu);
+ if (ret != BT_STATUS_SUCCESS) {
+ 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;
+}
+
+oal_status_t gattc_add_connection_info(bt_address_t *device_address, int conn_id, int instance_id)
+{
+ int ret = OAL_STATUS_SUCCESS;
+ bdstr_t bdstr;
+
+ OAL_CHECK_PARAMETER(device_address, return);
+ API_TRACE("Add connection info: [%s]", bdt_bd2str(device_address, &bdstr));
+ CHECK_OAL_GATT_ENABLED();
+ CHECK_SERVER_INSTANCE(instance_id);
+ if (__gatts_find_server_instance(instance_id) == NULL)
+ return OAL_STATUS_INTERNAL_ERROR;
+
+ ret = gatt_api->client->add_connection_info((bt_bdaddr_t *)device_address, conn_id, instance_id);
+ if (ret != BT_STATUS_SUCCESS) {
+ BT_ERR("GATT connection info add failed: %s", status2string(ret));
+ return convert_to_oal_status(ret);
+ }
+ return OAL_STATUS_SUCCESS;
+}
+
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff