When compare address, ignoring the case of the characters

[platform/core/connectivity/bluetooth-frwk.git] / bt-api / bt-hid-device.c

diff --git a/bt-api/bt-hid-device.c b/bt-api/bt-hid-device.c
index b287ca7..e0e8a53 100644 (file)
--- a/bt-api/bt-hid-device.c
+++ b/bt-api/bt-hid-device.c
@@ -97,10 +97,10 @@ static GVariant* __bt_hid_agent_dbus_send(const char *path,
        GDBusProxy *proxy = NULL;
        GDBusConnection *conn = NULL;
 
-       conn = _bt_gdbus_get_system_gconn();
+       conn = _bt_get_system_private_conn();
        retv_if(conn == NULL, NULL);
 
-       proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+       proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
                NULL, BT_HID_SERVICE_NAME, path, interface, NULL, err);
        if (proxy == NULL) {
                BT_ERR("Unable to allocate new proxy");
@@ -120,7 +120,7 @@ static hid_connected_device_info_t *__find_hid_info_with_address(const char *rem
 
        for (l = device_list; l != NULL; l = l->next) {
                hid_connected_device_info_t *info = l->data;
-               if (g_strcmp0((const char *)info->address, (const char *)remote_addr) == 0)
+               if (strcasecmp((const char *)info->address, (const char *)remote_addr) == 0)
                        return info;
        }
        return NULL;
@@ -286,7 +286,7 @@ static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
                        &len, &err);
        if (status == G_IO_STATUS_NORMAL) {
                BT_INFO("Parsing Data");
-               bluetooth_hid_received_data_t data = {0};
+               bluetooth_hid_received_data_t recv_data = {0};
                header = buffer[0];
                type = header & BT_HID_HEADER_TRANS_MASK;
                param = header & BT_HID_HEADER_PARAM_MASK;
@@ -297,121 +297,111 @@ static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
                if (event_info == NULL)
                        return FALSE;
 
-               data.address = g_strdup(info->address);
+               recv_data.address = g_strdup(info->address);
                switch (type) {
                case BT_HID_TRANS_HANDSHAKE:
                        BT_INFO("TRANS HANDSHAKE");
-                       data.type = HTYPE_TRANS_HANDSHAKE;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_HANDSHAKE;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                break;
 
                case BT_HID_TRANS_HID_CONTROL:
                        BT_INFO("HID CONTROL");
-                       data.type = HTYPE_TRANS_HID_CONTROL;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_HID_CONTROL;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                break;
 
                case BT_HID_TRANS_DATA:
                        BT_INFO("TRANS DATA");
-                       data.type = HTYPE_TRANS_DATA;
+                       recv_data.type = HTYPE_TRANS_DATA;
                        if (param & BT_HID_DATA_RTYPE_INPUT) {
                                BT_INFO("Input Report");
-                               data.param = PTYPE_DATA_RTYPE_INPUT;
-                               data.buffer_size = len;
-                               data.buffer = (char *) malloc(sizeof(char) * len);
-                               if (data.buffer)
-                                       memcpy(data.buffer, buffer, len);
+                               recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                               recv_data.buffer_size = len;
+                               recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                               memcpy(recv_data.buffer, buffer, len);
                        } else {
                                BT_INFO("Out Report");
-                               data.param = PTYPE_DATA_RTYPE_OUTPUT;
-                               data.buffer_size = len;
-                               data.buffer = (char *) malloc(sizeof(char) * len);
-                               if (data.buffer)
-                                       memcpy(data.buffer, buffer, len);
+                               recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
+                               recv_data.buffer_size = len;
+                               recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                               memcpy(recv_data.buffer, buffer, len);
                        }
                break;
 
                case BT_HID_TRANS_GET_REPORT: {
                        BT_INFO("Get Report");
-                       data.type = HTYPE_TRANS_GET_REPORT;
+                       recv_data.type = HTYPE_TRANS_GET_REPORT;
                        if (param & BT_HID_DATA_RTYPE_INPUT) {
                                BT_INFO("Input Report");
-                               data.param = PTYPE_DATA_RTYPE_INPUT;
+                               recv_data.param = PTYPE_DATA_RTYPE_INPUT;
                        } else {
                                BT_INFO("Output Report");
-                               data.param = PTYPE_DATA_RTYPE_OUTPUT;
+                               recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
                        }
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_SET_REPORT: {
                        BT_INFO("Set Report");
-                       data.type = HTYPE_TRANS_SET_REPORT;
+                       recv_data.type = HTYPE_TRANS_SET_REPORT;
                        if (param & BT_HID_DATA_RTYPE_INPUT) {
                                BT_INFO("Input Report");
-                               data.param = PTYPE_DATA_RTYPE_INPUT;
+                               recv_data.param = PTYPE_DATA_RTYPE_INPUT;
                        } else {
                                BT_INFO("Output Report");
-                               data.param = PTYPE_DATA_RTYPE_OUTPUT;
+                               recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
                        }
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_GET_PROTOCOL:{
                        BT_INFO("Get_PROTOCOL");
-                       data.type = HTYPE_TRANS_GET_PROTOCOL;
-                       data.param = PTYPE_DATA_RTYPE_INPUT;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_GET_PROTOCOL;
+                       recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_SET_PROTOCOL:{
                        BT_INFO("Set_PROTOCOL");
-                       data.type = HTYPE_TRANS_SET_PROTOCOL;
-                       data.param = PTYPE_DATA_RTYPE_INPUT;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_SET_PROTOCOL;
+                       recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_GET_IDLE:{
                        BT_INFO("Get_IDLE");
-                       data.type = HTYPE_TRANS_GET_IDLE;
-                       data.param = PTYPE_DATA_RTYPE_INPUT;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_GET_IDLE;
+                       recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_SET_IDLE:{
                        BT_INFO("Set_IDLE");
-                       data.type = HTYPE_TRANS_SET_IDLE;
-                       data.param = PTYPE_DATA_RTYPE_INPUT;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_SET_IDLE;
+                       recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
@@ -420,7 +410,7 @@ static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
                        BT_ERR("Send Handshake Message");
                        guint8 type = BT_HID_TRANS_HANDSHAKE |
                                BT_HID_HSHK_ERR_UNSUPPORTED_REQUEST;
-                       data.type = HTYPE_TRANS_UNKNOWN;
+                       recv_data.type = HTYPE_TRANS_UNKNOWN;
                        int fd = g_io_channel_unix_get_fd(chan);
                        int bytes = write(fd,  &type, sizeof(type));
                        BT_INFO("Bytes Written %d", bytes);
@@ -429,13 +419,13 @@ static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
        }
 
        _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DATA_RECEIVED,
-                               BLUETOOTH_ERROR_NONE, &data,
+                               BLUETOOTH_ERROR_NONE, &recv_data,
                                event_info->cb, event_info->user_data);
-       if (data.buffer)
-               g_free(data.buffer);
+       if (recv_data.buffer)
+               g_free(recv_data.buffer);
 
-       if (data.address)
-               g_free((char *)data.address);
+       if (recv_data.address)
+               g_free((char *)recv_data.address);
        } else {
                BT_ERR("Error while reading data %d [%s]", status, info->address);
                if (err) {
@@ -482,13 +472,13 @@ int _bt_hid_device_get_fd(const char *address, int *ctrl, int *intr)
        int index1 = 0;
        int index2 = 0;
        GUnixFDList *out_fd_list = NULL;
-       conn = _bt_gdbus_get_system_gconn();
+       conn = _bt_get_system_private_conn();
        retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 
        adapter_path = _bt_get_device_object_path((char *)address);
        retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
        BT_INFO_C("Device : %s", adapter_path);
-       server_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+       server_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
                        NULL, BT_BLUEZ_NAME,
                        adapter_path, "org.bluez.Input1",  NULL, NULL);
        g_free(adapter_path);