}
}
g_free(uuid_string);
- g_free(data);
}
static void __bt_handle_gatt_server_service_added(event_gatts_srvc_prm_t *event)
}
}
- g_free(event);
g_free(uuid_str);
}
_bt_uuid_to_string(&(event->charctr_uuid), uuid_str);
BT_INFO("GATT Added Characteristic: UUID: [%s]", uuid_str);
- g_free(event);
g_free(uuid_str);
}
_bt_uuid_to_string(&(event->descrptr_uuid), uuid_str);
BT_INFO("GATT Added Descriptor: UUID: [%s]", uuid_str);
- g_free(event);
g_free(uuid_str);
}
break;
}
}
-
- g_free(event);
}
static void __bt_handle_gatt_server_service_stopped(event_gatts_srvc_t *event)
break;
}
}
-
- g_free(event);
}
static void __bt_handle_gatt_server_service_deleted(event_gatts_srvc_t *event)
break;
}
}
-
- g_free(event);
}
static struct gatt_client_info_t *__bt_find_remote_gatt_client_info(char *address)
int result = BLUETOOTH_ERROR_NONE;
struct gatt_client_info_t *conn_info = NULL;
bluetooth_device_address_t dev_addr;
+ GVariant *param = NULL;
char *address = g_malloc0(BT_ADDRESS_STRING_SIZE);
if (!conn_info) {
BT_INFO("Conn Info absent: But no need to Send Local GATT Server Connected event to apps");
-#if 0
+
param = g_variant_new("(is)", result, address);
/* Send event to application */
_bt_send_event(BT_DEVICE_EVENT,
BLUETOOTH_EVENT_GATT_SERVER_CONNECTED, /* Local device is GATT server */
param);
-#endif
+
/* Save Connection info */
conn_info = g_new0(struct gatt_client_info_t, 1);
conn_info->addr = g_strdup(address);
int result = BLUETOOTH_ERROR_NONE;
struct gatt_client_info_t *conn_info = NULL;
bluetooth_device_address_t dev_addr;
-
- char *address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ GVariant *param = NULL;
+ char address[BT_ADDRESS_STRING_SIZE];
memcpy(dev_addr.addr, event->address.addr, 6);
conn_info = __bt_find_remote_gatt_client_info(address);
if (conn_info) {
BT_INFO("No need to Send Local GATT Server Disconnected event to apps, just remove remote client info");
-#if 0
+
param = g_variant_new("(is)", result, address);
/* Send event to application */
_bt_send_event(BT_DEVICE_EVENT,
BLUETOOTH_EVENT_GATT_SERVER_DISCONNECTED, /* Local device is GATT server */
param);
-#endif
+
/* Remove info from List */
gatt_client_info_list = g_slist_remove(gatt_client_info_list, conn_info);
BT_INFO("Total num of connected GATT clients [%d]", g_slist_length(gatt_client_info_list));
g_free(conn_info->addr);
g_free(conn_info);
}
-
- g_free(address);
}
#else
}
#endif
+
+static void __bt_handle_gatt_server_acquire_write_requested(event_gatts_srvc_acquire_attr_t *event)
+{
+ GVariant *param = NULL;
+ int result = BLUETOOTH_ERROR_NONE;
+ struct gatt_server_req_info *req_info = NULL;
+ bluetooth_device_address_t dev_addr;
+ char adress[BT_ADDRESS_STRING_SIZE] = {'/0',};
+
+ BT_INFO("GATT Server ACQUIRE Write Req Connection ID: [%d]", event->attr_trans.conn_id);
+ BT_INFO("GATT Server ACQUIRE Write Req Transaction ID:[%d]", event->attr_trans.trans_id);
+ BT_INFO("GATT Server ACQUIRE Write Req Attribute Handle: [%d]", event->attr_trans.attr_handle);
+
+ //adress = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ memcpy(dev_addr.addr, event->address.addr, 6);
+
+ req_info = g_new0(struct gatt_server_req_info, 1);
+ req_info->request_id = event->attr_trans.trans_id;
+ req_info->attribute_handle = event->attr_trans.attr_handle;
+ req_info->connection_id = event->attr_trans.conn_id;
+ req_info->request_type = BLUETOOTH_GATT_REQUEST_TYPE_ACQUIRE_WRITE;
+ gatt_server_requests = g_slist_append(gatt_server_requests, req_info);
+
+ _bt_convert_addr_type_to_string(adress,
+ (unsigned char *)dev_addr.addr);
+
+ param = g_variant_new("(iiiiiis)", result,
+ event->attr_trans.conn_id,
+ event->attr_trans.trans_id,
+ event->attr_trans.attr_handle,
+ event->mtu, event->attr_trans.offset, adress);
+ BT_INFO("GATT Server ACQUIRE Write Req Attribute remote adress : [%s]", adress);
+
+ _bt_send_event(BT_GATT_SERVER_EVENT,
+ BLUETOOTH_EVENT_GATT_SERVER_ACQUIRE_WRITE,
+ param);
+
+}
+
+static void __bt_handle_gatt_server_acquire_notify_requested(event_gatts_srvc_acquire_attr_t *event)
+{
+ GVariant *param = NULL;
+ int result = BLUETOOTH_ERROR_NONE;
+ struct gatt_server_req_info *req_info = NULL;
+
+ BT_INFO("GATT Server ACQUIRE Notify Req Connection ID: [%d]", event->attr_trans.conn_id);
+ BT_INFO("GATT Server ACQUIRE Notify Req Transaction ID:[%d]", event->attr_trans.trans_id);
+ BT_INFO("GATT Server ACQUIRE Notify Req Attribute Handle: [%d]", event->attr_trans.attr_handle);
+
+ req_info = g_new0(struct gatt_server_req_info, 1);
+ req_info->request_id = event->attr_trans.trans_id;
+ req_info->attribute_handle = event->attr_trans.attr_handle;
+ req_info->connection_id = event->attr_trans.conn_id;
+ req_info->request_type = BLUETOOTH_GATT_REQUEST_TYPE_ACQUIRE_NOTIFY;
+ gatt_server_requests = g_slist_append(gatt_server_requests, req_info);
+
+ param = g_variant_new("(iiiiii)", result,
+ event->attr_trans.conn_id,
+ event->attr_trans.trans_id,
+ event->attr_trans.attr_handle,
+ event->mtu, event->attr_trans.offset);
+
+ BT_INFO("GATT Server ACQUIRE Notify Req Attribute : ");
+
+ _bt_send_event(BT_GATT_SERVER_EVENT,
+ BLUETOOTH_EVENT_GATT_SERVER_ACQUIRE_NOTIFY,
+ param);
+}
+
static void __bt_handle_gatt_server_write_requested(event_gatts_srvc_write_attr_t *event)
{
char *address;
if (event->length <= 0) {
BT_INFO("GATT Server write requested, but length of attr value is 0");
- g_free(event);
return;
}
BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED,
param);
- g_free(event);
g_free(write_val);
}
_bt_send_event(BT_GATT_SERVER_EVENT,
BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED,
param);
-
- g_free(event);
}
static void __bt_handle_gatt_server_indicate_confirmed(event_gatts_ind_cnfrm_t *event)
param);
BT_INFO("Received Indication confirm for client number [%d]", recvd);
- g_free(event);
g_free(address);
}
BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED,
param);
- g_free(event);
g_free(address);
}
conn_info = __bt_find_remote_gatt_client_info_from_conn_id(event->conn_id);
if (conn_info == NULL) {
BT_ERR("Cant find connection Information");
- g_free(event);
return;
}
BT_INFO("Got connection Info GATT client [%s] MTU Size [%d]",
_bt_send_event(BT_GATT_SERVER_EVENT,
BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
param);
- g_free(event);
}
static void __bt_gatt_event_handler(int event_type, gpointer event_data)
switch (event_type) {
case OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED: {
BT_INFO("OAL Event: Server Instance Registered");
- event_gatts_register_t* event = g_memdup(event_data, sizeof(event_gatts_register_t));
/* GATT Server Registered event is handled in MAIN thread context */
- __bt_handle_server_instance_registered(event);
+ __bt_handle_server_instance_registered((event_gatts_register_t *)event_data);
break;
}
case OAL_EVENT_GATTS_SERVICE_ADDED: {
BT_INFO("OAL Event: GATT Service added");
- event_gatts_srvc_prm_t *service_parm = g_memdup(event_data, sizeof(event_gatts_srvc_prm_t));
- __bt_handle_gatt_server_service_added(service_parm);
+ __bt_handle_gatt_server_service_added((event_gatts_srvc_prm_t *)event_data);
break;
}
case OAL_EVENT_GATTS_CHARACTERISTIC_ADDED: {
BT_INFO("OAL Event: GATT characteristic added");
- event_gatts_srvc_charctr_t *char_parm = g_memdup(event_data, sizeof(event_gatts_srvc_charctr_t));
- __bt_handle_gatt_server_characteristic_added(char_parm);
+ __bt_handle_gatt_server_characteristic_added((event_gatts_srvc_charctr_t *)event_data);
break;
}
case OAL_EVENT_GATTS_DESCRIPTOR_ADDED: {
BT_INFO("OAL Event: GATT descriptor added");
- event_gatts_srvc_descr_t *desc_parm = g_memdup(event_data, sizeof(event_gatts_srvc_descr_t));
- __bt_handle_gatt_server_descriptor_added(desc_parm);
+ __bt_handle_gatt_server_descriptor_added((event_gatts_srvc_descr_t *)event_data);
break;
}
case OAL_EVENT_GATTS_SERVICE_STARTED: {
BT_INFO("OAL Event: GATT Service started");
- event_gatts_srvc_t *svc_started = g_memdup(event_data, sizeof(event_gatts_srvc_t));
- __bt_handle_gatt_server_service_started(svc_started);
+ __bt_handle_gatt_server_service_started((event_gatts_srvc_t *)event_data);
break;
}
case OAL_EVENT_GATTS_SERVICE_STOPED: {
BT_INFO("OAL Event: GATT Service stopped");
- event_gatts_srvc_t *svc_stopped = g_memdup(event_data, sizeof(event_gatts_srvc_t));
- __bt_handle_gatt_server_service_stopped(svc_stopped);
+ __bt_handle_gatt_server_service_stopped((event_gatts_srvc_t *)event_data);
break;
}
case OAL_EVENT_GATTS_SERVICE_DELETED: {
BT_INFO("OAL Event: GATT Service deleted");
- event_gatts_srvc_t *svc_deleted = g_memdup(event_data, sizeof(event_gatts_srvc_t));
- __bt_handle_gatt_server_service_deleted(svc_deleted);
+ __bt_handle_gatt_server_service_deleted((event_gatts_srvc_t *) event_data);
break;
}
case OAL_EVENT_GATTS_CONNECTION_COMPLETED: {
BT_INFO("OAL Event: GATT Server Connected");
- event_gatts_conn_t* event = g_memdup(event_data, sizeof(event_gatts_conn_t));
- __bt_handle_gatt_server_connection_state(event);
+ __bt_handle_gatt_server_connection_state((event_gatts_conn_t *)event_data);
break;
}
case OAL_EVENT_GATTS_DISCONNECTION_COMPLETED: {
BT_INFO("OAL Event: GATT Server Disconnected");
- event_gatts_conn_t* event = g_memdup(event_data, sizeof(event_gatts_conn_t));
- __bt_handle_gatt_server_disconnection_state(event);
+ __bt_handle_gatt_server_disconnection_state((event_gatts_conn_t *)event_data);
break;
}
case OAL_EVENT_GATTS_REQUEST_READ: {
BT_INFO("OAL Event: GATT Server Read Request");
- event_gatts_srvc_read_attr_t *read_req = g_memdup(event_data, sizeof(event_gatts_srvc_read_attr_t));
- __bt_handle_gatt_server_read_requested(read_req);
+ __bt_handle_gatt_server_read_requested((event_gatts_srvc_read_attr_t *)event_data);
break;
}
case OAL_EVENT_GATTS_REQUEST_WRITE: {
BT_INFO("OAL Event: GATT Server Write Request");
- event_gatts_srvc_write_attr_t *write_req = g_memdup(event_data, sizeof(event_gatts_srvc_write_attr_t));
- __bt_handle_gatt_server_write_requested(write_req);
+ __bt_handle_gatt_server_write_requested((event_gatts_srvc_write_attr_t *)event_data);
+ break;
+ }
+ case OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE: {
+ BT_INFO("OAL Event: GATT Server Acquire Write Request");
+ __bt_handle_gatt_server_acquire_write_requested((event_gatts_srvc_acquire_attr_t*)event_data);
+ break;
+ }
+ case OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY: {
+ BT_INFO("OAL Event: GATT ServerAcquire Notify Request");
+ __bt_handle_gatt_server_acquire_notify_requested((event_gatts_srvc_acquire_attr_t*)event_data);
break;
}
case OAL_EVENT_GATTS_IND_CONFIRM: {
BT_INFO("OAL Event: GATT Server Indication confirmed");
- event_gatts_ind_cnfrm_t *parm = g_memdup(event_data, sizeof(event_gatts_ind_cnfrm_t));
- __bt_handle_gatt_server_indicate_confirmed(parm);
+ __bt_handle_gatt_server_indicate_confirmed((event_gatts_ind_cnfrm_t *)event_data);
break;
}
case OAL_EVENT_GATTS_NOTIFICATION: { /* Tizen Platform Specific */
BT_INFO("OAL Event: GATT Server DisConnected");
- event_gatts_notif_t* notif = g_memdup(event_data, sizeof(event_gatts_notif_t));
- __bt_handle_gatt_server_notification_changed(notif);
+ __bt_handle_gatt_server_notification_changed((event_gatts_notif_t *)event_data);
break;
}
case OAL_EVENT_GATTS_MTU_CHANGED: {
BT_INFO("OAL Event: GATT Server MTU changed event callback");
- event_gatts_mtu_changed_t *mtu_changed = g_memdup(event_data, sizeof(event_gatts_mtu_changed_t));
- __bt_handle_gatt_mtu_changed_event(mtu_changed);
+ __bt_handle_gatt_mtu_changed_event((event_gatts_mtu_changed_t *)event_data);
break;
}
#ifdef TIZEN_GATT_CLIENT
return BLUETOOTH_ERROR_NONE;
}
+int _bt_gatt_server_acquire_send_response(char *sender, bluetooth_gatt_server_acquire_response_params_t *param , void *fd_list)
+{
+ BT_CHECK_PARAMETER(sender, return);
+ BT_CHECK_PARAMETER(param, return);
+ struct gatt_server_req_info *req_info = NULL;
+ int ret = OAL_STATUS_SUCCESS;
+
+
+ BT_INFO("GATT acquire Server Response: Req Type [%d] req_id [%d] fd [%d] mtu[%d]",
+ param->req_type, param->request_id,
+ param->fd,
+ param->mtu);
+
+ /* Search for matching Request in List */
+ req_info = __bt_gatt_server_find_request_info(param->request_id, param->req_type);
+ if (!req_info) {
+ BT_ERR("GATT acquire Server Req Info not found for current response..return Error");
+ return BLUETOOTH_ERROR_NOT_IN_OPERATION;
+ }
+
+ ret = gatt_send_response_acquire(req_info->connection_id, param->request_id, 0, param->fd, param->mtu, fd_list);
+
+ if (ret != OAL_STATUS_SUCCESS) {
+ BT_ERR("ret: %d", ret);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ BT_INFO("GATT acquire Server Response successfully sent");
+ /* Remove GATT server request from list */
+ gatt_server_requests = g_slist_remove(gatt_server_requests, req_info);
+ g_free(req_info->addr);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+
+
int _bt_gatt_server_send_indication(char *sender, bluetooth_device_address_t *dev_addr,
bluetooth_gatt_att_data_t *data,
bluetooth_gatt_server_indication_params_t *param)
memcpy(&info->char_uuid, char_info->uuid, BLUETOOTH_UUID_HEX_MAX_LEN);
info->char_inst_id = char_info->inst_id;
+ /* Fill property of the parent characteristic of this descriptor */
+ info->char_props_map = char_info->props;
+
+ info->count = g_slist_length(char_info->descs);
+ BT_INFO("Total count of Descriptors [%d]", info->count);
+
if (!char_info->descs) {
BT_ERR("No Descriptors browsed for address [%s]", conn_info->addr);
return;
}
- info->count = g_slist_length(char_info->descs);
- BT_INFO("Total count of Descriptors [%d]", info->count);
-
for (l = char_info->descs; l != NULL; l = g_slist_next(l)) {
desc_info = (bt_gatt_descriptor_info_t*)l->data;
if (desc_info == NULL)
/* Fill instance ID of Descriptor */
info->inst_id[count] = desc_info->inst_id;
- /* Fill property of the parent characteristic of this descriptor */
- info->char_props_map = char_info->props;
/* Increment count of Descriptor browsed */
count++;
__bt_gatt_handle_pending_request_info(result, BT_CONNECT_LE,
address, BT_ADDRESS_STRING_SIZE);
BT_ERR("Failed to connect Local GATT Remote addr[%s]", address);
+ g_free(address);
return;
}
} else {
svc_info->chars = g_slist_append(svc_info->chars, char_info);
} else {
/* If found, then return */
- BT_INFO("Characteristic browsed is already presesnt");
+ BT_INFO("update char property as Characteristic browsed is already present");
+ char_info->props |= event_data->char_prop;
}
} else {
/* If Not success: Means Charc browse is completed */
__bt_gatt_handle_pending_request_info(result, BT_CONNECT_LE, address,
BT_ADDRESS_STRING_SIZE);
+ g_free(address);
}
static void __bt_handle_client_notification_registered(
return BLUETOOTH_ERROR_NONE;
}
+/*acquire Notify*/
+int _bt_gatt_acquire_notify(bluetooth_gatt_client_char_prop_info_t *chr, int *fd, int *mtu)
+{
+ struct gatt_server_info_t *conn_info = NULL;
+ oal_gatt_srvc_id_t srvc_id;
+ oal_gatt_id_t char_id;
+ int ret = OAL_STATUS_SUCCESS;
+ char *addr;
+
+ BT_CHECK_PARAMETER(chr, return);
+
+ BT_INFO("+");
+
+ addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
+ _bt_convert_addr_type_to_string(addr, chr->device_address.addr);
+
+ /* Check if remote GATT Server is connected or not */
+ conn_info = __bt_find_remote_gatt_server_info(addr);
+ if (conn_info) {
+ BT_INFO("GATT Server [%s] is connected, conn Id [%d]",
+ conn_info->addr, conn_info->connection_id);
+ } else {
+ BT_ERR("GATT Server is not yet connected..");
+ g_free(addr);
+ return BLUETOOTH_ERROR_NOT_CONNECTED;
+ }
+
+ srvc_id.is_prmry = TRUE;
+ srvc_id.id.inst_id = chr->svc.instance_id;
+ memcpy(srvc_id.id.uuid.uuid, chr->svc.uuid, BLUETOOTH_UUID_HEX_MAX_LEN);
+
+ char_id.inst_id = chr->characteristic.instance_id;
+ memcpy(char_id.uuid.uuid, chr->characteristic.uuid, BLUETOOTH_UUID_HEX_MAX_LEN);
+
+ ret = gattc_acquire_notify(conn_info->connection_id, &srvc_id, &char_id, fd, mtu);
+
+ if (ret != OAL_STATUS_SUCCESS) {
+ BT_ERR("ret: %d", ret);
+ g_free(addr);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ BT_INFO("GATT characterstics FD [%d] mtu[%d]", *fd, *mtu);
+ g_free(addr);
+ return BLUETOOTH_ERROR_NONE;
+}
+
+/*acquire Write*/
+int _bt_gatt_acquire_write(bluetooth_gatt_client_char_prop_info_t *chr, int *fd, int *mtu)
+{
+
+ struct gatt_server_info_t *conn_info = NULL;
+ oal_gatt_srvc_id_t srvc_id;
+ oal_gatt_id_t char_id;
+ int ret = OAL_STATUS_SUCCESS;
+ char *addr;
+
+ BT_CHECK_PARAMETER(chr, return);
+
+ BT_INFO("+");
+
+ addr = g_malloc0(sizeof(char) * BT_ADDRESS_STRING_SIZE);
+ _bt_convert_addr_type_to_string(addr, chr->device_address.addr);
+
+ /* Check if remote GATT Server is connected or not */
+ conn_info = __bt_find_remote_gatt_server_info(addr);
+ if (conn_info) {
+ BT_INFO("GATT Server [%s] is connected, conn Id [%d]",
+ conn_info->addr, conn_info->connection_id);
+ } else {
+ BT_ERR("GATT Server is not yet connected..");
+ g_free(addr);
+ return BLUETOOTH_ERROR_NOT_CONNECTED;
+ }
+
+ srvc_id.is_prmry = TRUE;
+ srvc_id.id.inst_id = chr->svc.instance_id;
+ memcpy(srvc_id.id.uuid.uuid, chr->svc.uuid, BLUETOOTH_UUID_HEX_MAX_LEN);
+
+ char_id.inst_id = chr->characteristic.instance_id;
+ memcpy(char_id.uuid.uuid, chr->characteristic.uuid, BLUETOOTH_UUID_HEX_MAX_LEN);
+
+ ret = gattc_acquire_write(conn_info->connection_id, &srvc_id, &char_id,
+ OAL_GATT_AUTH_REQ_NONE, fd, mtu);
+ if (ret != OAL_STATUS_SUCCESS) {
+ BT_ERR("ret: %d", ret);
+ g_free(addr);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ BT_INFO("GATT characterstics FD [%d] mtu [%d]", *fd, *mtu);
+ g_free(addr);
+ return BLUETOOTH_ERROR_NONE;
+
+}
+
/* Write Characteristic */
int _bt_gatt_write_characteristic_value_by_type(
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff