const bluetooth_device_address_t *device_addr)
{
GSList *l;
- char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
- char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
-
- _bt_convert_addr_type_to_string(device_address,
- (unsigned char *)device_addr->addr);
for (l = service_monitor_list; l != NULL; l = l->next) {
- char device_address2[BT_ADDRESS_STRING_SIZE] = { 0 };
- char secure_address2[BT_ADDRESS_STRING_SIZE] = { 0 };
bluetooth_device_address_t *addr = l->data;
- _bt_convert_addr_type_to_string(device_address2,
- (unsigned char *)addr->addr);
- _bt_convert_addr_string_to_secure_string(secure_address,
- device_address);
- _bt_convert_addr_string_to_secure_string(secure_address2,
- device_address2);
- BT_INFO("service_monitor_list [%s] - Input [%s]",
- secure_address2, secure_address);
-
if (!memcmp(device_addr, addr,
sizeof(bluetooth_device_address_t)))
return TRUE;
if (!g_strcmp0(key, "UUID")) {
char *name = NULL;
service->uuid = g_variant_dup_string(value, &len);
- _bt_get_uuid_specification_name(service->uuid, &name);
- BT_INFO("======> Service : %s [%s]", service->uuid, name);
+ bluetooth_get_uuid_name(service->uuid, &name);
+ BT_INFO("%s %s [%s]", service_handle + 37, service->uuid, name);
g_free(name);
} else if (!g_strcmp0(key, "Primary")) {
service->primary = g_variant_get_boolean(value);
char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
char temp_address[BT_ADDRESS_STRING_SIZE] = { 0 };
int ret = BLUETOOTH_ERROR_INTERNAL;
+ int idx = 0;
- BT_INFO("+");
+ BT_DBG("+");
BT_CHECK_PARAMETER(address, return);
BT_CHECK_PARAMETER(prim_svc, return);
BT_CHECK_ENABLED(return);
if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) != 0)
continue;
- BT_DBG("Object Path: %s", object_path);
+ BT_DBG("[%d] Object Path : %s", idx++, object_path);
while (g_variant_iter_loop(svc_iter, "{sv}", &key, &value)) {
if (g_strcmp0(key, "Primary") == 0) {
if (g_variant_get_boolean(value))
g_variant_get(char_value, "ao", &char_iter);
gp_array = g_ptr_array_new();
- while (g_variant_iter_loop(char_iter, "&o", &char_handle));
+ while (g_variant_iter_loop(char_iter, "&o", &char_handle))
g_ptr_array_add(gp_array, (gpointer)char_handle);
if (gp_array->len != 0) {
retv_if(permission == NULL, ret);
- BT_INFO("permission = %s", permission);
-
if (!g_strcmp0(permission, "broadcast"))
ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_BROADCAST;
else if (!g_strcmp0(permission, "read"))
return ret;
}
+static void __convert_permission_flag_to_str(unsigned int permission)
+{
+ char perm[200] = { 0, };
+
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_BROADCAST)
+ g_strlcat(perm, "broadcast ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ)
+ g_strlcat(perm, "read ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE_NO_RESPONSE)
+ g_strlcat(perm, "write-without-response ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE)
+ g_strlcat(perm, "write ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY)
+ g_strlcat(perm, "notify ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE)
+ g_strlcat(perm, "indicate ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_SIGNED_WRITE)
+ g_strlcat(perm, "authenticated-signed-writes ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_RELIABLE_WRITE)
+ g_strlcat(perm, "reliable-write ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITABLE_AUXILIARIES)
+ g_strlcat(perm, "writable-auxiliaries ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_READ)
+ g_strlcat(perm, "encrypt-read ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_WRITE)
+ g_strlcat(perm, "encrypt-write ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_READ)
+ g_strlcat(perm, "encrypt-authenticated-read ", sizeof(perm));
+ if (permission & BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_WRITE)
+ g_strlcat(perm, "encrypt-authenticated-write ", sizeof(perm));
+
+ BT_INFO("permission [0x%04x] : %s\n", permission, perm);
+ return;
+}
+
BT_EXPORT_API int bluetooth_gatt_get_characteristics_property(
const char *char_handle, bt_gatt_char_property_t *characteristic)
{
if (!g_strcmp0(key, "UUID")) {
char *name = NULL;
characteristic->uuid = g_variant_dup_string(value, &len);
- _bt_get_uuid_specification_name(characteristic->uuid, &name);
- BT_INFO("Characteristic : %s [%s]", characteristic->uuid, name);
+ bluetooth_get_uuid_name(characteristic->uuid, &name);
+ BT_INFO("%s %s [%s]", char_handle + 37, characteristic->uuid, name);
g_free(name);
} else if (!g_strcmp0(key, "Value")) {
gb_array = g_byte_array_new();
while (g_variant_iter_loop(char_perm_iter, "s", &permission))
characteristic->permission |= __get_permission_flag(permission);
+ __convert_permission_flag_to_str(characteristic->permission);
g_variant_iter_free(char_perm_iter);
} else if (!g_strcmp0(key, "Descriptors")) {
if (!g_strcmp0(key, "UUID")) {
char *name = NULL;
descriptor->uuid = g_variant_dup_string(value, &len);
- _bt_get_uuid_specification_name(descriptor->uuid, &name);
+ bluetooth_get_uuid_name(descriptor->uuid, &name);
BT_INFO("Descriptor : %s [%s]", descriptor->uuid, name);
g_free(name);
} else if (!g_strcmp0(key, "Value")) {
return BLUETOOTH_ERROR_NONE;
}
+static int __bluetooth_get_att_error_code(GError *error)
+{
+ int att_ecode = 0;
+ int len;
+ char *str = NULL;
+
+ BT_ERR("Error : %s", error->message);
+ str = g_strrstr(error->message, "ATT error: 0x");
+ if (str) {
+ len = strlen(str);
+ att_ecode = g_ascii_xdigit_value(str[len - 2]) << 4;
+ att_ecode += g_ascii_xdigit_value(str[len - 1]);
+ } else
+ return BLUETOOTH_ATT_ERROR_INTERNAL;
+
+ switch (att_ecode) {
+ case BLUETOOTH_ATT_ERROR_READ_NOT_PERMITTED:
+ BT_ERR("Read not permitted");
+ break;
+ case BLUETOOTH_ATT_ERROR_WRITE_NOT_PERMITTED:
+ BT_ERR("Write not permitted");
+ break;
+ case BLUETOOTH_ATT_ERROR_AUTHENTICATION:
+ case BLUETOOTH_ATT_ERROR_INSUFFICIENT_ENCRYPTION:
+ case BLUETOOTH_ATT_ERROR_INSUFFICIENT_ENCRYPTION_KEY_SIZE:
+ BT_ERR("Not paired");
+ break;
+ case BLUETOOTH_ATT_ERROR_INVALID_OFFSET:
+ BT_ERR("Invalid offset");
+ break;
+ case BLUETOOTH_ATT_ERROR_INVALID_ATTRIBUTE_VALUE_LEN:
+ BT_ERR("Invalid Length");
+ break;
+ case BLUETOOTH_ATT_ERROR_AUTHORIZATION:
+ BT_ERR("Operation not Authorized");
+ break;
+ }
+
+ if (att_ecode >= 0x80 && att_ecode <= 0x9F)
+ BT_ERR("Application error");
+
+ return att_ecode;
+}
+
static void __bluetooth_internal_read_cb(GObject *source_object,
- GAsyncResult *res,
- gpointer user_data)
+ GAsyncResult *res, gpointer user_data)
{
GError *error = NULL;
- bt_user_info_t *user_info;
- bt_gatt_char_value_t char_value = { 0, };
GDBusConnection *system_gconn = NULL;
GVariant *value;
- GByteArray *gp_byte_array = NULL;
+ bt_user_info_t *user_info;
GVariantIter *iter;
+ GByteArray *gp_byte_array = NULL;
guint8 g_byte;
- int ret = BLUETOOTH_ERROR_NONE;
+ int att_ecode = 0;
+ bt_gatt_resp_data_t *resp_data = user_data;
BT_DBG("+");
- user_info = _bt_get_user_data(BT_COMMON);
system_gconn = _bt_gdbus_get_system_gconn();
value = g_dbus_connection_call_finish(system_gconn, res, &error);
- if (error) {
- BT_ERR("Error : %s \n", error->message);
- if (g_strrstr(error->message, "Not paired"))
- ret = BLUETOOTH_ERROR_NOT_PAIRED;
- else
- ret = BLUETOOTH_ERROR_INTERNAL;
+ user_info = _bt_get_user_data(BT_COMMON);
+ if (!user_info) {
+ g_free(resp_data);
+ if (error) {
+ BT_ERR("Error : %s", error->message);
+ g_clear_error(&error);
+ return;
+ }
+ g_variant_unref(value);
+ return;
+ }
+ if (error) {
+ att_ecode = __bluetooth_get_att_error_code(error);
g_clear_error(&error);
- if (user_info) {
- _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
- ret, NULL,
- user_info->cb, user_info->user_data);
- }
- g_free(user_data);
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
+ att_ecode, resp_data,
+ user_info->cb, user_info->user_data);
+ g_free(resp_data);
return;
}
- char_value.char_handle = user_data;
gp_byte_array = g_byte_array_new();
g_variant_get(value, "(ay)", &iter);
g_byte_array_append(gp_byte_array, &g_byte, 1);
if (gp_byte_array->len != 0) {
- char_value.val_len = gp_byte_array->len;
- char_value.char_value = gp_byte_array->data;
+ resp_data->len = gp_byte_array->len;
+ resp_data->value = gp_byte_array->data;
}
- if (user_info) {
- _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
- BLUETOOTH_ERROR_NONE, &char_value,
- user_info->cb, user_info->user_data);
- }
+ _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
+ BLUETOOTH_ATT_ERROR_NONE, resp_data,
+ user_info->cb, user_info->user_data);
+ g_free(resp_data);
- g_free(char_value.char_handle);
g_byte_array_free(gp_byte_array, TRUE);
- g_variant_unref(value);
g_variant_iter_free(iter);
+ g_variant_unref(value);
BT_DBG("-");
}
-BT_EXPORT_API int bluetooth_gatt_read_characteristic_value(const char *characteristic)
+BT_EXPORT_API int bluetooth_gatt_read_characteristic_value(const char *chr,
+ gpointer user_data)
{
GDBusConnection *conn;
- char *handle;
+ bt_gatt_resp_data_t *resp_data;
+ GVariantBuilder *builder = NULL;
+ guint16 offset = 0;
- BT_CHECK_PARAMETER(characteristic, return);
+ BT_CHECK_PARAMETER(chr, return);
BT_CHECK_ENABLED(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- handle = g_strdup(characteristic);
+ resp_data = g_malloc0(sizeof(bt_gatt_resp_data_t));
+ resp_data->user_data = user_data;
- g_dbus_connection_call(conn,
- BT_BLUEZ_NAME,
- characteristic,
- GATT_CHAR_INTERFACE,
- "ReadValue",
- NULL,
- G_VARIANT_TYPE("(ay)"),
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- NULL,
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ /*offset*/
+ g_variant_builder_add(builder, "{sv}", "offset",
+ g_variant_new("q", offset));
+
+ /* Device Object path*/
+// g_variant_builder_add(builder, "{sv}", "device",
+// g_variant_new_object("o", NULL));
+
+ g_dbus_connection_call(conn, BT_BLUEZ_NAME, chr, GATT_CHAR_INTERFACE,
+ "ReadValue", g_variant_new("(a{sv})", builder),
+ G_VARIANT_TYPE("(ay)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL,
(GAsyncReadyCallback)__bluetooth_internal_read_cb,
- (gpointer)handle);
+ (gpointer)resp_data);
+ g_variant_builder_unref(builder);
return BLUETOOTH_ERROR_NONE;
}
+static void __bluetooth_internal_write_cb(GObject *source_object,
+ GAsyncResult *res, gpointer user_data)
+{
+ GError *error = NULL;
+ GDBusConnection *system_gconn = NULL;
+ bt_user_info_t *user_info;
+ GVariant *value;
+ int att_ecode = 0;
+ bt_gatt_resp_data_t *resp_data = user_data;
+
+ system_gconn = _bt_gdbus_get_system_gconn();
+ value = g_dbus_connection_call_finish(system_gconn, res, &error);
+
+ user_info = _bt_get_user_data(BT_COMMON);
+ if (!user_info) {
+ g_free(resp_data);
+ if (error) {
+ BT_ERR("Error : %s", error->message);
+ g_clear_error(&error);
+ return;
+ }
+ g_variant_unref(value);
+ return;
+ }
+
+ if (error) {
+ att_ecode = __bluetooth_get_att_error_code(error);
+ g_clear_error(&error);
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_CHAR,
+ att_ecode, resp_data,
+ user_info->cb, user_info->user_data);
+ g_free(resp_data);
+ return;
+ }
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_CHAR,
+ BLUETOOTH_ATT_ERROR_NONE, resp_data,
+ user_info->cb, user_info->user_data);
+ g_free(resp_data);
+
+ g_variant_unref(value);
+ return;
+}
+
BT_EXPORT_API int bluetooth_gatt_set_characteristics_value(
const char *char_handle, const guint8 *value, int length)
{
- GVariant *val;
- GVariantBuilder *builder;
+ GVariant *val, *options;
+ GVariantBuilder *builder1;
+ GVariantBuilder *builder2;
GError *error = NULL;
GDBusConnection *conn;
int i = 0;
+ guint16 offset = 0;
BT_DBG("+");
BT_CHECK_PARAMETER(char_handle, return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
-
+ builder1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < length; i++)
- g_variant_builder_add(builder, "y", value[i]);
-
- val = g_variant_new("(ay)", builder);
+ g_variant_builder_add(builder1, "y", value[i]);
- g_dbus_connection_call_sync(conn,
- BT_BLUEZ_NAME,
- char_handle,
- GATT_CHAR_INTERFACE,
- "WriteValue",
- val,
- NULL,
- G_DBUS_CALL_FLAGS_NONE,
- -1, NULL, &error);
-
- if (error) {
- BT_ERR("Set value Failed: %s", error->message);
- g_clear_error(&error);
- g_variant_builder_unref(builder);
- return BLUETOOTH_ERROR_INTERNAL;
- }
+ val = g_variant_new("ay", builder1);
- g_variant_builder_unref(builder);
+ builder2 = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ /*offset*/
+ g_variant_builder_add(builder2, "{sv}", "offset",
+ g_variant_new_uint16(offset));
- BT_DBG("-");
- return BLUETOOTH_ERROR_NONE;
-}
+ /* Device Object path*/
+// g_variant_builder_add(builder2, "{sv}", "device",
+// g_variant_new_object("o", NULL));
-static void __bluetooth_internal_write_cb(GObject *source_object,
- GAsyncResult *res,
- gpointer user_data)
-{
- GError *error = NULL;
- bt_user_info_t *user_info;
- GDBusConnection *system_gconn = NULL;
- GVariant *value;
- int result = BLUETOOTH_ERROR_NONE;
- guint8 att_ecode = 0;
+ options = g_variant_new("a{sv}", builder2);
- user_info = _bt_get_user_data(BT_COMMON);
+ g_dbus_connection_call(conn,
+ BT_BLUEZ_NAME,
+ char_handle,
+ GATT_CHAR_INTERFACE,
+ "WriteValue",
+ g_variant_new("(@ay@a{sv})",
+ val, options),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1, NULL,
+ (GAsyncReadyCallback)__bluetooth_internal_write_cb,
+ NULL);
- system_gconn = _bt_gdbus_get_system_gconn();
- value = g_dbus_connection_call_finish(system_gconn, res, &error);
if (error) {
- BT_ERR("Error : %s \n", error->message);
+ BT_ERR("Set value Failed: %s", error->message);
g_clear_error(&error);
- result = BLUETOOTH_ERROR_INTERNAL;
- } else {
- g_variant_get(value, "(y)", &att_ecode);
- if (att_ecode) {
- result = att_ecode;
- BT_ERR("ATT Error code: %d \n", att_ecode);
- }
- }
-
- if (user_info) {
- _bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_CHAR,
- result, NULL,
- user_info->cb, user_info->user_data);
- } else {
- BT_ERR("user info is null");
+ g_variant_builder_unref(builder1);
+ return BLUETOOTH_ERROR_INTERNAL;
}
+ g_variant_builder_unref(builder1);
+ g_variant_builder_unref(builder2);
- if (value)
- g_variant_unref(value);
-
- return;
+ BT_DBG("-");
+ return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_gatt_set_characteristics_value_by_type(
- const char *char_handle, const guint8 *value, int length, guint8 write_type)
+ const char *chr, const guint8 *value, int length,
+ guint8 write_type, gpointer user_data)
{
- GVariant *val;
- GVariantBuilder *builder;
+ GVariant *val, *options;
+ GVariantBuilder *builder1;
+ GVariantBuilder *builder2;
GDBusConnection *conn;
+ guint16 offset = 0;
int i = 0;
int ret = BLUETOOTH_ERROR_NONE;
+ bt_gatt_resp_data_t *resp_data;
- BT_CHECK_PARAMETER(char_handle, return);
+ BT_CHECK_PARAMETER(chr, return);
BT_CHECK_PARAMETER(value, return);
retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
BT_CHECK_ENABLED_INTERNAL(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ builder1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < length; i++)
- g_variant_builder_add(builder, "y", value[i]);
+ g_variant_builder_add(builder1, "y", value[i]);
- val = g_variant_new("ay", builder);
- g_dbus_connection_call(conn,
- BT_BLUEZ_NAME,
- char_handle,
- GATT_CHAR_INTERFACE,
+ val = g_variant_new("ay", builder1);
+
+ builder2 = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ /*offset*/
+ g_variant_builder_add(builder2, "{sv}", "offset",
+ g_variant_new_uint16(offset));
+
+ /* Device Object path*/
+// g_variant_builder_add(builder2, "{sv}", "device",
+// g_variant_new_object("o", NULL));
+
+ options = g_variant_new("a{sv}", builder2);
+
+ resp_data = g_malloc0(sizeof(bt_gatt_resp_data_t));
+ resp_data->user_data = user_data;
+
+ g_dbus_connection_call(conn, BT_BLUEZ_NAME, chr, GATT_CHAR_INTERFACE,
"WriteValuebyType",
- g_variant_new("(y@ay)", write_type, val),
- G_VARIANT_TYPE("(y)"),
- G_DBUS_CALL_FLAGS_NONE,
- -1, NULL,
+ g_variant_new("(y@ay@a{sv})", write_type, val, options),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL,
(GAsyncReadyCallback)__bluetooth_internal_write_cb,
- NULL);
+ (gpointer)resp_data);
+
+ g_variant_builder_unref(builder1);
+ g_variant_builder_unref(builder2);
- g_variant_builder_unref(builder);
return ret;
}
BT_EXPORT_API int bluetooth_gatt_set_characteristics_value_request(
const char *char_handle, const guint8 *value, int length)
{
- GVariant *val;
+ GVariant *val, *options;
GDBusConnection *conn;
- GVariantBuilder *builder;
+ GVariantBuilder *builder1;
+ GVariantBuilder *builder2;
+ guint offset = 0;
int i;
BT_DBG("+");
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ builder1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < length; i++) {
- g_variant_builder_add(builder, "y", value[i]);
+ g_variant_builder_add(builder1, "y", value[i]);
BT_DBG("value [] = %d", value[i]);
}
- val = g_variant_new("(ay)", builder);
+ val = g_variant_new("ay", builder1);
+
+ builder2 = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ /*offset*/
+ g_variant_builder_add(builder2, "{sv}", "offset",
+ g_variant_new_uint16(offset));
+
+ /* Device Object path*/
+// g_variant_builder_add(builder2, "{sv}", "device",
+// g_variant_new_object("o", NULL));
+
+ options = g_variant_new("a{sv}", builder2);
g_dbus_connection_call(conn,
BT_BLUEZ_NAME,
char_handle,
GATT_CHAR_INTERFACE,
"WriteValue",
- val,
+ g_variant_new("(@ay@a{sv})",
+ val, options),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1, NULL,
(GAsyncReadyCallback)__bluetooth_internal_write_cb,
NULL);
- g_variant_builder_unref(builder);
+ g_variant_builder_unref(builder1);
+ g_variant_builder_unref(builder2);
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
user_info = _bt_get_user_data(BT_COMMON);
value = g_dbus_proxy_call_finish(proxy, res, &error);
+ characteristic.handle = user_data;
if (value == NULL) {
if (error != NULL) {
BLUETOOTH_ERROR_INTERNAL, NULL,
user_info->cb, user_info->user_data);
}
- g_free(user_data);
+ g_free(characteristic.handle);
g_object_unref(proxy);
return;
}
}
}
- characteristic.handle = user_data;
if (user_info) {
_bt_common_event_cb(BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED,
ret, &characteristic, user_info->cb, user_info->user_data);
}
bluetooth_gatt_free_char_property(&characteristic);
+ g_free(characteristic.handle);
g_variant_iter_free(char_iter);
g_variant_unref(value);
BT_DBG("-");
gpointer user_data)
{
GError *error = NULL;
- bt_user_info_t *user_info;
- bt_gatt_char_property_t char_value = { 0, };
GDBusConnection *system_gconn = NULL;
GVariant *value;
+ bt_user_info_t *user_info;
GByteArray *gp_byte_array = NULL;
GVariantIter *iter;
guint8 g_byte;
+ int att_ecode = 0;
+ bt_gatt_resp_data_t *resp_data = user_data;
BT_DBG("+");
- user_info = _bt_get_user_data(BT_COMMON);
- system_gconn = _bt_gdbus_get_system_gconn();
- char_value.handle = user_data;
+ system_gconn = _bt_gdbus_get_system_gconn();
value = g_dbus_connection_call_finish(system_gconn, res, &error);
+ user_info = _bt_get_user_data(BT_COMMON);
+ if (!user_info) {
+ g_free(resp_data);
+ if (error) {
+ BT_ERR("Error : %s", error->message);
+ g_clear_error(&error);
+ return;
+ }
+ g_variant_unref(value);
+ return;
+ }
+
if (error) {
- BT_ERR("Error : %s \n", error->message);
+ att_ecode = __bluetooth_get_att_error_code(error);
g_clear_error(&error);
- if (user_info) {
- _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_DESC,
- BLUETOOTH_ERROR_INTERNAL, NULL,
- user_info->cb, user_info->user_data);
- }
- g_free(char_value.handle);
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_DESC,
+ att_ecode, resp_data,
+ user_info->cb, user_info->user_data);
+ g_free(resp_data);
return;
}
gp_byte_array = g_byte_array_new();
g_variant_get(value, "(ay)", &iter);
- while (g_variant_iter_loop(iter, "y", &g_byte))
+ while (g_variant_iter_loop(iter, "y", &g_byte))
g_byte_array_append(gp_byte_array, &g_byte, 1);
if (gp_byte_array->len != 0) {
- char_value.val_len = (unsigned int)gp_byte_array->len;
- char_value.description = (char *)gp_byte_array->data;
+ resp_data->len = gp_byte_array->len;
+ resp_data->value = gp_byte_array->data;
}
- if (user_info) {
- _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_DESC,
- BLUETOOTH_ERROR_NONE, &char_value,
- user_info->cb, user_info->user_data);
- }
+ _bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_DESC,
+ BLUETOOTH_ATT_ERROR_NONE, resp_data,
+ user_info->cb, user_info->user_data);
+ g_free(resp_data);
+
g_byte_array_free(gp_byte_array, TRUE);
- g_free(char_value.handle);
- g_variant_unref(value);
g_variant_iter_free(iter);
+ g_variant_unref(value);
BT_DBG("-");
}
-BT_EXPORT_API int bluetooth_gatt_read_descriptor_value(const char *char_descriptor)
+BT_EXPORT_API int bluetooth_gatt_read_descriptor_value(const char *desc,
+ gpointer user_data)
{
GDBusConnection *conn;
- char *handle;
+ GVariantBuilder *builder;
+ guint offset = 0;
+ bt_gatt_resp_data_t *resp_data;
BT_DBG("+");
- BT_CHECK_PARAMETER(char_descriptor, return);
+
+ BT_CHECK_PARAMETER(desc, return);
BT_CHECK_ENABLED(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- handle = g_strdup(char_descriptor);
+ resp_data = g_malloc0(sizeof(bt_gatt_resp_data_t));
+ resp_data->user_data = user_data;
- g_dbus_connection_call(conn,
- BT_BLUEZ_NAME,
- char_descriptor,
- GATT_DESC_INTERFACE,
- "ReadValue",
- NULL,
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ /*offset*/
+ g_variant_builder_add(builder, "{sv}", "offset",
+ g_variant_new("q", offset));
+ /* Device Object path*/
+// g_variant_builder_add(builder, "{sv}", "device",
+// g_variant_new("o", serv_info->serv_path));
+
+ g_dbus_connection_call(conn, BT_BLUEZ_NAME, desc, GATT_DESC_INTERFACE,
+ "ReadValue", g_variant_new("(a{sv})", builder),
G_VARIANT_TYPE("(ay)"),
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- NULL,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL,
(GAsyncReadyCallback)__bluetooth_internal_read_desc_cb,
- (gpointer)handle);
+ (gpointer)resp_data);
+ g_variant_builder_unref(builder);
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
static void __bluetooth_internal_write_desc_cb(GObject *source_object,
- GAsyncResult *res,
- gpointer user_data)
+ GAsyncResult *res, gpointer user_data)
{
GError *error = NULL;
bt_user_info_t *user_info;
GDBusConnection *system_gconn = NULL;
GVariant *value;
- int result = BLUETOOTH_ERROR_NONE;
- guint8 att_ecode = 0;
+ int att_ecode = BLUETOOTH_ATT_ERROR_NONE;
+ bt_gatt_resp_data_t *resp_data = user_data;
BT_DBG("+");
- user_info = _bt_get_user_data(BT_COMMON);
system_gconn = _bt_gdbus_get_system_gconn();
value = g_dbus_connection_call_finish(system_gconn, res, &error);
- if (error) {
- BT_ERR("Error : %s \n", error->message);
- g_clear_error(&error);
- result = BLUETOOTH_ERROR_INTERNAL;
- } else {
- g_variant_get(value, "(y)", &att_ecode);
- if (att_ecode) {
- result = att_ecode;
- BT_ERR("ATT Error code: %d \n", att_ecode);
+ user_info = _bt_get_user_data(BT_COMMON);
+ if (!user_info) {
+ g_free(resp_data);
+ if (error) {
+ BT_ERR("Error : %s", error->message);
+ g_clear_error(&error);
+ return;
}
+ g_variant_unref(value);
+ return;
}
- if (user_info) {
+ if (error) {
+ att_ecode = __bluetooth_get_att_error_code(error);
+ g_clear_error(&error);
+
_bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_DESC,
- result, NULL,
+ att_ecode, resp_data,
user_info->cb, user_info->user_data);
+ g_free(resp_data);
+ return;
}
- if (value)
- g_variant_unref(value);
+ _bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_DESC,
+ BLUETOOTH_ATT_ERROR_NONE, resp_data,
+ user_info->cb, user_info->user_data);
+ g_free(resp_data);
+ g_variant_unref(value);
BT_DBG("-");
}
-BT_EXPORT_API int bluetooth_gatt_write_descriptor_value(
- const char *desc_handle, const guint8 *value, int length)
+BT_EXPORT_API int bluetooth_gatt_write_descriptor_value(const char *desc,
+ const guint8 *value, int length, gpointer user_data)
{
- GVariant *val;
+ GVariant *val, *options;
GDBusConnection *conn;
- GVariantBuilder *builder;
+ GVariantBuilder *builder1;
+ GVariantBuilder *builder2;
+ guint offset = 0;
int i;
+ bt_gatt_resp_data_t *resp_data;
BT_DBG("+");
- BT_CHECK_PARAMETER(desc_handle, return);
+
+ BT_CHECK_PARAMETER(desc, return);
BT_CHECK_PARAMETER(value, return);
retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
BT_CHECK_ENABLED(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ builder1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < length; i++)
- g_variant_builder_add(builder, "y", value[i]);
+ g_variant_builder_add(builder1, "y", value[i]);
- val = g_variant_new("(ay)", builder);
+ val = g_variant_new("ay", builder1);
- g_dbus_connection_call(conn,
- BT_BLUEZ_NAME,
- desc_handle,
- GATT_DESC_INTERFACE,
- "WriteValue",
- val,
- G_VARIANT_TYPE("(y)"),
- G_DBUS_CALL_FLAGS_NONE,
- -1, NULL,
- (GAsyncReadyCallback)__bluetooth_internal_write_desc_cb,
- NULL);
+ builder2 = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ /*offset*/
+ g_variant_builder_add(builder2, "{sv}", "offset",
+ g_variant_new_uint16(offset));
- g_variant_builder_unref(builder);
+ /* Device Object path*/
+// g_variant_builder_add(builder2, "{sv}", "device",
+// g_variant_new_object("o", NULL));
+
+ options = g_variant_new("a{sv}", builder2);
+
+ resp_data = g_malloc0(sizeof(bt_gatt_resp_data_t));
+ resp_data->user_data = user_data;
+
+ g_dbus_connection_call(conn, BT_BLUEZ_NAME, desc, GATT_DESC_INTERFACE,
+ "WriteValue", g_variant_new("(@ay@a{sv})",
+ val, options), NULL,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL,
+ (GAsyncReadyCallback)__bluetooth_internal_write_desc_cb,
+ (gpointer)resp_data);
+
+ g_variant_builder_unref(builder1);
+ g_variant_builder_unref(builder2);
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
-BT_EXPORT_API int bluetooth_gatt_watch_characteristics(const char *char_handle)
+BT_EXPORT_API int bluetooth_gatt_watch_characteristics(const char *char_handle, const char *svc_name)
{
GDBusConnection *conn;
GError *error = NULL;
BT_CHECK_PARAMETER(char_handle, return);
BT_CHECK_ENABLED(return);
- BT_INFO_C("### Enable CCCD : %s", char_handle);
+ BT_INFO_C("### Enable CCCD : %s [%s]", char_handle + 15, svc_name);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff