Code optimize 67/183167/1
authorinjun.yang <injun.yang@samsung.com>
Tue, 3 Jul 2018 05:55:06 +0000 (14:55 +0900)
committerinjun.yang <injun.yang@samsung.com>
Tue, 3 Jul 2018 05:55:06 +0000 (14:55 +0900)
Change-Id: Id79d33f51003da6786e7bbd18b581836b7e75719
Signed-off-by: injun.yang <injun.yang@samsung.com>
bt-service/bt-request-handler.c
bt-service/bt-service-adapter-le.c
bt-service/bt-service-agent.c
bt-service/bt-service-avrcp-controller.c
bt-service/bt-service-common.c
bt-service/bt-service-device.c
bt-service/bt-service-event-receiver.c
bt-service/bt-service-util.c
bt-service/include/bt-service-common.h

index a8a145a..99613bc 100644 (file)
@@ -202,8 +202,8 @@ static void __bt_service_method(GDBusConnection *connection,
                        }
                }
 
-               BT_DBG("SERVICE TYPE [%d] SERVICE FUNC [%d]",
-                               service_type, service_function);
+               BT_DBG("Service type = %s, fn = %s (0x%x)", __bt_convert_service_type_to_string(service_type),
+                               _bt_convert_service_function_to_string(service_function), service_function);
                switch (service_type) {
                case BT_BLUEZ_SERVICE:
                        result = __bt_bluez_request(service_function,
@@ -1320,6 +1320,17 @@ int __bt_bluez_request(int function_name,
                meta_data.number = data.number;
                meta_data.duration = (int64_t) data.duration;
 
+               if (meta_data.title)
+                       BT_INFO("title [%s]", meta_data.title);
+               if (meta_data.artist)
+                       BT_INFO("artist [%s]", meta_data.artist);
+               if (meta_data.album)
+                       BT_INFO("album [%s]", meta_data.album);
+               if (meta_data.genre)
+                       BT_INFO("genre [%s]", meta_data.genre);
+               BT_INFO("total_tracks[%d], number[%d], duration[%d]",
+                               meta_data.total_tracks, meta_data.number, meta_data.duration);
+
                result = _bt_avrcp_set_track_info(&meta_data);
 
                g_free((gpointer)meta_data.title);
index 5882517..a9f61d1 100644 (file)
@@ -400,7 +400,7 @@ int _bt_set_advertising(const char *sender, int adv_handle, gboolean enable, gbo
                __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
 
        le_adv_slot[slot_id].is_advertising = enable;
-       BT_INFO_C("### Set advertising [%d]", enable);
+       BT_INFO_C("### Set advertising [%d], Slot id [%d]", enable, slot_id);
 
        if (ret)
                g_variant_unref(ret);
@@ -505,7 +505,7 @@ int _bt_set_custom_advertising(const char *sender, int adv_handle,
                _bt_unregister_adv_slot_owner(slot_id);
 
        le_adv_slot[slot_id].is_advertising = enable;
-       BT_INFO_C("### Set advertising [%d]", enable);
+       BT_INFO_C("### Set advertising [%d], Slot id [%d]", enable, slot_id);
        if (ret)
                g_variant_unref(ret);
 
@@ -897,10 +897,6 @@ int __bt_get_available_scan_filter_slot_id(void)
                return -1;
        }
        slot_check_list = g_malloc0(sizeof(gboolean) * le_feature_info.max_filter);
-       if (slot_check_list == NULL) {
-               BT_ERR("Fail to allocate memory");
-               return -1;
-       }
 
        for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
                scanner = l->data;
@@ -1247,19 +1243,17 @@ int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *fil
        scanner = __bt_find_scanner_from_list(sender);
        if (scanner == NULL) {
                scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
-               if (scanner) {
-                       scanner->sender = strdup(sender);
-                       scanner_list = g_slist_append(scanner_list, scanner);
-               }
+               scanner->sender = g_strdup(sender);
+               scanner_list = g_slist_append(scanner_list, scanner);
        }
 
-       filter_data = g_malloc0(sizeof(bluetooth_le_scan_filter_t));
-       if (filter_data) {
+
+       if (scanner) {
+               filter_data = g_malloc0(sizeof(bluetooth_le_scan_filter_t));
                memcpy(filter_data, filter, sizeof(bluetooth_le_scan_filter_t));
                filter_data->slot_id = *slot_id;
 
-               if (scanner)
-                       scanner->filter_list = g_slist_append(scanner->filter_list, filter_data);
+               scanner->filter_list = g_slist_append(scanner->filter_list, filter_data);
        }
 
        if (ret)
@@ -1364,9 +1358,7 @@ int _bt_start_le_scan(const char *sender)
 
        if (scanner == NULL) {
                scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
-               retv_if(scanner == NULL, BLUETOOTH_ERROR_INTERNAL);
-
-               scanner->sender = strdup(sender);
+               scanner->sender = g_strdup(sender);
                scanner_list = g_slist_append(scanner_list, scanner);
        }
 
index bda1d43..d231908 100644 (file)
@@ -961,12 +961,6 @@ static gboolean __bt_agent_is_device_blacklist(const char *address,
        rewind(fp);
 
        buffer = g_malloc0(sizeof(char) * size);
-       /* Fix : NULL_RETURNS */
-       if (buffer == NULL) {
-               BT_ERR("Fail to allocate memory");
-               fclose(fp);
-               return FALSE;
-       }
        result = fread((char *)buffer, 1, size, fp);
        fclose(fp);
        if (result != size) {
index ba406f0..9c87873 100644 (file)
@@ -496,6 +496,7 @@ static int __bt_avrcp_control_parse_properties(
                        metadata->genre = g_strdup(value_string);
                } else if (strcasecmp(key, "Duration") == 0) {
                        value_uint = g_variant_get_uint32(value);
+                       BT_DBG("Duration : %d", value_uint);
                        metadata->duration = value_uint;
                } else if (strcasecmp(key, "NumberOfTracks") == 0) {
                        value_uint = g_variant_get_uint32(value);
index ac97955..101e7a0 100644 (file)
@@ -1075,6 +1075,265 @@ const char *_bt_convert_profile_state_to_string(bt_profile_state_t state)
        return NULL;
 }
 
+const char *_bt_convert_service_function_to_string(int function)
+{
+       int i;
+
+       typedef struct {
+               int function;
+               const char *function_name;
+       } bt_function_name_t;
+
+       const bt_function_name_t bt_functions[] = {
+               {BT_CHECK_ADAPTER, "BT_CHECK_ADAPTER"},
+               {BT_ENABLE_ADAPTER, "BT_ENABLE_ADAPTER"},
+               {BT_DISABLE_ADAPTER, "BT_DISABLE_ADAPTER"},
+               {BT_RECOVER_ADAPTER, "BT_RECOVER_ADAPTER"},
+               {BT_SET_DISCOVERABLE_TIME, "BT_SET_DISCOVERABLE_TIME"},
+               {BT_GET_DISCOVERABLE_TIME, "BT_GET_DISCOVERABLE_TIME"},
+               {BT_IGNORE_AUTO_PAIRING, "BT_IGNORE_AUTO_PAIRING"},
+               {BT_GET_LOCAL_ADDRESS, "BT_GET_LOCAL_ADDRESS"},
+               {BT_GET_LOCAL_VERSION, "BT_GET_LOCAL_VERSION"},
+               {BT_GET_LOCAL_NAME, "BT_GET_LOCAL_NAME"},
+               {BT_SET_LOCAL_NAME, "BT_SET_LOCAL_NAME"},
+               {BT_IS_SERVICE_USED, "BT_IS_SERVICE_USED"},
+               {BT_GET_DISCOVERABLE_MODE, "BT_GET_DISCOVERABLE_MODE"},
+               {BT_SET_DISCOVERABLE_MODE, "BT_SET_DISCOVERABLE_MODE"},
+               {BT_START_DISCOVERY, "BT_START_DISCOVERY"},
+               {BT_START_CUSTOM_DISCOVERY, "BT_START_CUSTOM_DISCOVERY"},
+               {BT_CANCEL_DISCOVERY, "BT_CANCEL_DISCOVERY"},
+               {BT_START_LE_DISCOVERY, "BT_START_LE_DISCOVERY"},
+               {BT_STOP_LE_DISCOVERY, "BT_STOP_LE_DISCOVERY"},
+               {BT_IS_DISCOVERYING, "BT_IS_DISCOVERYING"},
+               {BT_IS_LE_DISCOVERYING, "BT_IS_LE_DISCOVERYING"},
+               {BT_ENABLE_RSSI, "BT_ENABLE_RSSI"},
+               {BT_GET_RSSI, "BT_GET_RSSI"},
+               {BT_IS_CONNECTABLE, "BT_IS_CONNECTABLE"},
+               {BT_SET_CONNECTABLE, "BT_SET_CONNECTABLE"},
+               {BT_GET_BONDED_DEVICES, "BT_GET_BONDED_DEVICES"},
+               {BT_RESET_ADAPTER, "BT_RESET_ADAPTER"},
+               {BT_SET_ADVERTISING, "BT_SET_ADVERTISING"},
+               {BT_SET_CUSTOM_ADVERTISING, "BT_SET_CUSTOM_ADVERTISING"},
+               {BT_SET_ADVERTISING_PARAMETERS, "BT_SET_ADVERTISING_PARAMETERS"},
+               {BT_GET_ADVERTISING_DATA, "BT_GET_ADVERTISING_DATA"},
+               {BT_SET_ADVERTISING_DATA, "BT_SET_ADVERTISING_DATA"},
+               {BT_SET_SCAN_PARAMETERS, "BT_SET_SCAN_PARAMETERS"},
+               {BT_GET_SCAN_RESPONSE_DATA, "BT_GET_SCAN_RESPONSE_DATA"},
+               {BT_SET_SCAN_RESPONSE_DATA, "BT_SET_SCAN_RESPONSE_DATA"},
+               {BT_IS_ADVERTISING, "BT_IS_ADVERTISING"},
+               {BT_SET_MANUFACTURER_DATA, "BT_SET_MANUFACTURER_DATA"},
+               {BT_LE_CONN_UPDATE, "BT_LE_CONN_UPDATE"},
+               {BT_LE_READ_MAXIMUM_DATA_LENGTH, "BT_LE_READ_MAXIMUM_DATA_LENGTH"},
+               {BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH, "BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH"},
+               {BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH, "BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH"},
+               {BT_LE_SET_DATA_LENGTH, "BT_LE_SET_DATA_LENGTH"},
+               {BT_ADD_WHITE_LIST, "BT_ADD_WHITE_LIST"},
+               {BT_REMOVE_WHITE_LIST, "BT_REMOVE_WHITE_LIST"},
+               {BT_CLEAR_WHITE_LIST, "BT_CLEAR_WHITE_LIST"},
+               {BT_REGISTER_SCAN_FILTER, "BT_REGISTER_SCAN_FILTER"},
+               {BT_UNREGISTER_SCAN_FILTER, "BT_UNREGISTER_SCAN_FILTER"},
+               {BT_UNREGISTER_ALL_SCAN_FILTERS, "BT_UNREGISTER_ALL_SCAN_FILTERS"},
+               {BT_IS_SCAN_FILTER_SUPPORTED, "BT_IS_SCAN_FILTER_SUPPORTED"},
+               {BT_GET_PROFILE_CONNECTED_DEVICES, "BT_GET_PROFILE_CONNECTED_DEVICES"},
+               {BT_ENABLE_FORCE_HCI_DUMP, "BT_ENABLE_FORCE_HCI_DUMP"},
+               {BT_SET_PASSKEY_NOTIFICATION, "BT_SET_PASSKEY_NOTIFICATION"},
+               {BT_BOND_DEVICE, "BT_BOND_DEVICE"},
+               {BT_BOND_DEVICE_BY_TYPE, "BT_BOND_DEVICE_BY_TYPE"},
+               {BT_CANCEL_BONDING, "BT_CANCEL_BONDING"},
+               {BT_PASSKEY_REPLY, "BT_PASSKEY_REPLY"},
+               {BT_PASSKEY_CONFIRMATION_REPLY, "BT_PASSKEY_CONFIRMATION_REPLY"},
+               {BT_UNBOND_DEVICE, "BT_UNBOND_DEVICE"},
+               {BT_SEARCH_SERVICE, "BT_SEARCH_SERVICE"},
+               {BT_CANCEL_SEARCH_SERVICE, "BT_CANCEL_SEARCH_SERVICE"},
+               {BT_GET_BONDED_DEVICE, "BT_GET_BONDED_DEVICE"},
+               {BT_GET_IS_ALIAS_SET, "BT_GET_IS_ALIAS_SET"},
+               {BT_SET_ALIAS, "BT_SET_ALIAS"},
+               {BT_SET_AUTHORIZATION, "BT_SET_AUTHORIZATION"},
+               {BT_UNSET_AUTHORIZATION, "BT_UNSET_AUTHORIZATION"},
+               {BT_IS_DEVICE_CONNECTED, "BT_IS_DEVICE_CONNECTED"},
+               {BT_GET_CONNECTED_LINK_TYPE, "BT_GET_CONNECTED_LINK_TYPE"},
+               {BT_SET_PIN_CODE, "BT_SET_PIN_CODE"},
+               {BT_UNSET_PIN_CODE, "BT_UNSET_PIN_CODE"},
+               {BT_UPDATE_LE_CONNECTION_MODE, "BT_UPDATE_LE_CONNECTION_MODE"},
+               {BT_SET_PROFILE_TRUSTED, "BT_SET_PROFILE_TRUSTED"},
+               {BT_GET_PROFILE_TRUSTED, "BT_GET_PROFILE_TRUSTED"},
+               {BT_HID_CONNECT, "BT_HID_CONNECT"},
+               {BT_HID_DISCONNECT, "BT_HID_DISCONNECT"},
+               {BT_HID_DEVICE_ACTIVATE, "BT_HID_DEVICE_ACTIVATE"},
+               {BT_HID_DEVICE_DEACTIVATE, "BT_HID_DEVICE_DEACTIVATE"},
+               {BT_HID_DEVICE_CONNECT, "BT_HID_DEVICE_CONNECT"},
+               {BT_HID_DEVICE_DISCONNECT, "BT_HID_DEVICE_DISCONNECT"},
+               {BT_HID_DEVICE_SEND_MOUSE_EVENT, "BT_HID_DEVICE_SEND_MOUSE_EVENT"},
+               {BT_HID_DEVICE_SEND_KEY_EVENT, "BT_HID_DEVICE_SEND_KEY_EVENT"},
+               {BT_HID_DEVICE_SEND_CUSTOM_EVENT, "BT_HID_DEVICE_SEND_CUSTOM_EVENT"},
+               {BT_HID_DEVICE_SEND_REPLY_TO_REPORT, "BT_HID_DEVICE_SEND_REPLY_TO_REPORT"},
+               {BT_HID_ENABLE_BARCODE_FEATURE, "BT_HID_ENABLE_BARCODE_FEATURE"},
+               {BT_NETWORK_ACTIVATE, "BT_NETWORK_ACTIVATE"},
+               {BT_NETWORK_DEACTIVATE, "BT_NETWORK_DEACTIVATE"},
+               {BT_NETWORK_CONNECT, "BT_NETWORK_CONNECT"},
+               {BT_NETWORK_DISCONNECT, "BT_NETWORK_DISCONNECT"},
+               {BT_NETWORK_SERVER_DISCONNECT, "BT_NETWORK_SERVER_DISCONNECT"},
+               {BT_AUDIO_CONNECT, "BT_AUDIO_CONNECT"},
+               {BT_AUDIO_DISCONNECT, "BT_AUDIO_DISCONNECT"},
+               {BT_AG_CONNECT, "BT_AG_CONNECT"},
+               {BT_AG_DISCONNECT, "BT_AG_DISCONNECT"},
+               {BT_AV_CONNECT, "BT_AV_CONNECT"},
+               {BT_AV_DISCONNECT, "BT_AV_DISCONNECT"},
+               {BT_AV_SOURCE_CONNECT, "BT_AV_SOURCE_CONNECT"},
+               {BT_AV_SOURCE_DISCONNECT, "BT_AV_SOURCE_DISCONNECT"},
+               {BT_HF_CONNECT, "BT_HF_CONNECT"},
+               {BT_HF_DISCONNECT, "BT_HF_DISCONNECT"},
+               {BT_GET_SPEAKER_GAIN, "BT_GET_SPEAKER_GAIN"},
+               {BT_SET_SPEAKER_GAIN, "BT_SET_SPEAKER_GAIN"},
+               {BT_SET_CONTENT_PROTECT, "BT_SET_CONTENT_PROTECT"},
+               {BT_OOB_READ_LOCAL_DATA, "BT_OOB_READ_LOCAL_DATA"},
+               {BT_OOB_ADD_REMOTE_DATA, "BT_OOB_ADD_REMOTE_DATA"},
+               {BT_OOB_REMOVE_REMOTE_DATA, "BT_OOB_REMOVE_REMOTE_DATA"},
+               {BT_AVRCP_SET_TRACK_INFO, "BT_AVRCP_SET_TRACK_INFO"},
+               {BT_AVRCP_SET_PROPERTY, "BT_AVRCP_SET_PROPERTY"},
+               {BT_AVRCP_SET_PROPERTIES, "BT_AVRCP_SET_PROPERTIES"},
+               {BT_AVRCP_CONTROL_CONNECT, "BT_AVRCP_CONTROL_CONNECT"},
+               {BT_AVRCP_CONTROL_DISCONNECT, "BT_AVRCP_CONTROL_DISCONNECT"},
+               {BT_AVRCP_TARGET_CONNECT, "BT_AVRCP_TARGET_CONNECT"},
+               {BT_AVRCP_TARGET_DISCONNECT, "BT_AVRCP_TARGET_DISCONNECT"},
+               {BT_AVRCP_HANDLE_CONTROL, "BT_AVRCP_HANDLE_CONTROL"},
+               {BT_AVRCP_CONTROL_SET_PROPERTY, "BT_AVRCP_CONTROL_SET_PROPERTY"},
+               {BT_AVRCP_CONTROL_GET_PROPERTY, "BT_AVRCP_CONTROL_GET_PROPERTY"},
+               {BT_AVRCP_GET_TRACK_INFO, "BT_AVRCP_GET_TRACK_INFO"},
+               {BT_OPP_PUSH_FILES, "BT_OPP_PUSH_FILES"},
+               {BT_OPP_CANCEL_PUSH, "BT_OBT_OPP_IS_PUSHING_FILESPP_CANCEL_PUSH"},
+               {BT_OPP_IS_PUSHING_FILES, "BT_OPP_IS_PUSHING_FILES"},
+               {BT_OPP_GET_TRANSFER_PROGRESS, "BT_OPP_GET_TRANSFER_PROGRESS"},
+               {BT_MAP_CREATE_SESSION, "BT_MAP_CREATE_SESSION"},
+               {BT_MAP_DESTROY_SESSION, "BT_MAP_DESTROY_SESSION"},
+               {BT_MAP_SET_FOLDER, "BT_MAP_SET_FOLDER"},
+               {BT_MAP_LIST_FOLDERS, "BT_MAP_LIST_FOLDERS"},
+               {BT_MAP_LIST_FILTER_FIELDS, "BT_MAP_LIST_FILTER_FIELDS"},
+               {BT_MAP_LIST_MESSAGES, "BT_MAP_LIST_MESSAGES"},
+               {BT_MAP_UPDATE_INBOX, "BT_MAP_UPDATE_INBOX"},
+               {BT_MAP_PUSH_MESSAGE, "BT_MAP_PUSH_MESSAGE"},
+               {BT_MAP_GET_MESSAGE, "BT_MAP_GET_MESSAGE"},
+               {BT_OBEX_SERVER_ALLOCATE, "BT_OBEX_SERVER_ALLOCATE"},
+               {BT_OBEX_SERVER_DEALLOCATE, "BT_OBEX_SERVER_DEALLOCATE"},
+               {BT_OBEX_SERVER_IS_ACTIVATED, "BT_OBEX_SERVER_IS_ACTIVATED"},
+               {BT_OBEX_SERVER_ACCEPT_CONNECTION, "BT_OBEX_SERVER_ACCEPT_CONNECTION"},
+               {BT_OBEX_SERVER_REJECT_CONNECTION, "BT_OBEX_SERVER_REJECT_CONNECTION"},
+               {BT_OBEX_SERVER_ACCEPT_FILE, "BT_OBEX_SERVER_ACCEPT_FILE"},
+               {BT_OBEX_SERVER_REJECT_FILE, "BT_OBEX_SERVER_REJECT_FILE"},
+               {BT_OBEX_SERVER_SET_PATH, "BT_OBEX_SERVER_SET_PATH"},
+               {BT_OBEX_SERVER_SET_ROOT, "BT_OBEX_SERVER_SET_ROOT"},
+               {BT_OBEX_SERVER_CANCEL_TRANSFER, "BT_OBEX_SERVER_CANCEL_TRANSFER"},
+               {BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS, "BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS"},
+               {BT_OBEX_SERVER_IS_RECEIVING, "BT_OBEX_SERVER_IS_RECEIVING"},
+               {BT_RFCOMM_CLIENT_CONNECT, "BT_RFCOMM_CLIENT_CONNECT"},
+               {BT_RFCOMM_CLIENT_CANCEL_CONNECT, "BT_RFCOMM_CLIENT_CANCEL_CONNECT"},
+               {BT_RFCOMM_CLIENT_IS_CONNECTED, "BT_RFCOMM_CLIENT_IS_CONNECTED"},
+               {BT_RFCOMM_SOCKET_DISCONNECT, "BT_RFCOMM_SOCKET_DISCONNECT"},
+               {BT_RFCOMM_SOCKET_WRITE, "BT_RFCOMM_SOCKET_WRITE"},
+               {BT_RFCOMM_CREATE_SOCKET, "BT_RFCOMM_CREATE_SOCKET"},
+               {BT_RFCOMM_REMOVE_SOCKET, "BT_RFCOMM_REMOVE_SOCKET"},
+               {BT_RFCOMM_LISTEN, "BT_RFCOMM_LISTEN"},
+               {BT_RFCOMM_IS_UUID_AVAILABLE, "BT_RFCOMM_IS_UUID_AVAILABLE"},
+               {BT_RFCOMM_ACCEPT_CONNECTION, "BT_RFCOMM_ACCEPT_CONNECTION"},
+               {BT_RFCOMM_REJECT_CONNECTION, "BT_RFCOMM_REJECT_CONNECTION"},
+               {BT_RFCOMM_CREATE_SOCKET_EX, "BT_RFCOMM_CREATE_SOCKET_EX"},
+               {BT_RFCOMM_REMOVE_SOCKET_EX, "BT_RFCOMM_REMOVE_SOCKET_EX"},
+               {BT_PBAP_CONNECT, "BT_PBAP_CONNECT"},
+               {BT_PBAP_DISCONNECT, "BT_PBAP_DISCONNECT"},
+               {BT_PBAP_GET_PHONEBOOK_SIZE, "BT_PBAP_GET_PHONEBOOK_SIZE"},
+               {BT_PBAP_GET_PHONEBOOK, "BT_PBAP_GET_PHONEBOOK"},
+               {BT_PBAP_GET_LIST, "BT_PBAP_GET_LIST"},
+               {BT_PBAP_PULL_VCARD, "BT_PBAP_PULL_VCARD"},
+               {BT_PBAP_PHONEBOOK_SEARCH, "BT_PBAP_PHONEBOOK_SEARCH"},
+               {BT_ENABLE_ADAPTER_LE, "BT_ENABLE_ADAPTER_LE"},
+               {BT_DISABLE_ADAPTER_LE, "BT_DISABLE_ADAPTER_LE"},
+               {BT_CONNECT_LE, "BT_CONNECT_LE"},
+               {BT_DISCONNECT_LE, "BT_DISCONNECT_LE"},
+               {BT_SET_LE_PRIVACY, "BT_SET_LE_PRIVACY"},
+               {BT_REQ_ATT_MTU, "BT_REQ_ATT_MTU"},
+               {BT_GET_ATT_MTU, "BT_GET_ATT_MTU"},
+               {BT_GET_DEVICE_IDA, "BT_GET_DEVICE_IDA"},
+               {BT_SET_LE_STATIC_RANDOM_ADDRESS, "BT_SET_LE_STATIC_RANDOM_ADDRESS"},
+               {BT_HDP_CONNECT, "BT_HDP_CONNECT"},
+               {BT_HDP_DISCONNECT, "BT_HDP_DISCONNECT"},
+               {BT_HDP_SEND_DATA, "BT_HDP_SEND_DATA"},
+               {BT_HDP_REGISTER_SINK_APP, "BT_HDP_REGISTER_SINK_APP"},
+               {BT_HDP_UNREGISTER_SINK_APP, "BT_HDP_UNREGISTER_SINK_APP"},
+               {BT_GATT_GET_PRIMARY_SERVICES, "BT_GATT_GET_PRIMARY_SERVICES"},
+               {BT_GATT_DISCOVER_CHARACTERISTICS, "BT_GATT_DISCOVER_CHARACTERISTICS"},
+               {BT_GATT_SET_PROPERTY_REQUEST, "BT_GATT_SET_PROPERTY_REQUEST"},
+               {BT_GATT_READ_CHARACTERISTIC, "BT_GATT_READ_CHARACTERISTIC"},
+               {BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR, "BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR"},
+               {BT_GATT_REGISTER_APPLICATION, "BT_GATT_REGISTER_APPLICATION"},
+               {BT_GATT_REGISTER_SERVICE, "BT_GATT_REGISTER_SERVICE"},
+               {BT_GATT_SEND_RESPONSE, "BT_GATT_SEND_RESPONSE"},
+               {BT_LE_IPSP_INIT, "BT_LE_IPSP_INIT"},
+               {BT_LE_IPSP_DEINIT, "BT_LE_IPSP_DEINIT"},
+               {BT_LE_IPSP_CONNECT, "BT_LE_IPSP_CONNECT"},
+               {BT_LE_IPSP_DISCONNECT, "BT_LE_IPSP_DISCONNECT"},
+               {BT_DPM_SET_ALLOW_BT_MODE, "BT_DPM_SET_ALLOW_BT_MODE"},
+               {BT_DPM_GET_ALLOW_BT_MODE, "BT_DPM_GET_ALLOW_BT_MODE"},
+               {BT_DPM_SET_DEVICE_RESTRITION, "BT_DPM_SET_DEVICE_RESTRITION"},
+               {BT_DPM_GET_DEVICE_RESTRITION, "BT_DPM_GET_DEVICE_RESTRITION"},
+               {BT_DPM_SET_UUID_RESTRITION, "BT_DPM_SET_UUID_RESTRITION"},
+               {BT_DPM_GET_UUID_RESTRITION, "BT_DPM_GET_UUID_RESTRITION"},
+               {BT_DPM_ADD_DEVICES_BLACKLIST, "BT_DPM_ADD_DEVICES_BLACKLIST"},
+               {BT_DPM_ADD_DEVICES_WHITELIST, "BT_DPM_ADD_DEVICES_WHITELIST"},
+               {BT_DPM_ADD_UUIDS_BLACKLIST, "BT_DPM_ADD_UUIDS_BLACKLIST"},
+               {BT_DPM_ADD_UUIDS_WHITELIST, "BT_DPM_ADD_UUIDS_WHITELIST"},
+               {BT_DPM_CLEAR_DEVICES_BLACKLIST, "BT_DPM_CLEAR_DEVICES_BLACKLIST"},
+               {BT_DPM_CLEAR_DEVICES_WHITELIST, "BT_DPM_CLEAR_DEVICES_WHITELIST"},
+               {BT_DPM_CLEAR_UUIDS_BLACKLIST, "BT_DPM_CLEAR_UUIDS_BLACKLIST"},
+               {BT_DPM_CLEAR_UUIDS_WHITELIST, "BT_DPM_CLEAR_UUIDS_WHITELIST"},
+               {BT_DPM_REMOVE_DEVICE_BLACKLIST, "BT_DPM_REMOVE_DEVICE_BLACKLIST"},
+               {BT_DPM_REMOVE_DEVICE_WHITELIST, "BT_DPM_REMOVE_DEVICE_WHITELIST"},
+               {BT_DPM_REMOVE_UUID_BLACKLIST, "BT_DPM_REMOVE_UUID_BLACKLIST"},
+               {BT_DPM_REMOVE_UUID_WHITELIST, "BT_DPM_REMOVE_UUID_WHITELIST"},
+               {BT_DPM_GET_DEVICES_BLACKLIST, "BT_DPM_GET_DEVICES_BLACKLIST"},
+               {BT_DPM_GET_DEVICES_WHITELIST, "BT_DPM_GET_DEVICES_WHITELIST"},
+               {BT_DPM_GET_UUIDS_BLACKLIST, "BT_DPM_GET_UUIDS_BLACKLIST"},
+               {BT_DPM_GET_UUIDS_WHITELIST, "BT_DPM_GET_UUIDS_WHITELIST"},
+               {BT_DPM_SET_ALLOW_OUTGOING_CALL, "BT_DPM_SET_ALLOW_OUTGOING_CALL"},
+               {BT_DPM_GET_ALLOW_OUTGOING_CALL, "BT_DPM_GET_ALLOW_OUTGOING_CALL"},
+               {BT_DPM_SET_PAIRING_STATE, "BT_DPM_SET_PAIRING_STATE"},
+               {BT_DPM_GET_PAIRING_STATE, "BT_DPM_GET_PAIRING_STATE"},
+               {BT_DPM_SET_PROFILE_STATE, "BT_DPM_SET_PROFILE_STATE"},
+               {BT_DPM_GET_PROFILE_STATE, "BT_DPM_GET_PROFILE_STATE"},
+               {BT_DPM_SET_DESKROP_CONNECTIVITY_STATE, "BT_DPM_SET_DESKROP_CONNECTIVITY_STATE"},
+               {BT_DPM_GET_DESKROP_CONNECTIVITY_STATE, "BT_DPM_GET_DESKROP_CONNECTIVITY_STATE"},
+               {BT_DPM_SET_DISCOVERABLE_STATE, "BT_DPM_SET_DISCOVERABLE_STATE"},
+               {BT_DPM_GET_DISCOVERABLE_STATE, "BT_DPM_GET_DISCOVERABLE_STATE"},
+               {BT_DPM_SET_LIMITED_DISCOVERABLE_STATE, "BT_DPM_SET_LIMITED_DISCOVERABLE_STATE"},
+               {BT_DPM_GET_LIMITED_DISCOVERABLE_STATE, "BT_DPM_GET_LIMITED_DISCOVERABLE_STATE"},
+               {BT_DPM_SET_DATA_TRANSFER_STATE, "BT_DPM_SET_DATA_TRANSFER_STATE"},
+               {BT_DPM_GET_DATA_TRANSFER_STATE, "BT_DPM_GET_DATA_TRANSFER_STATE"},
+               {BT_PXP_MONITOR_SET_PROPERTY, "BT_PXP_MONITOR_SET_PROPERTY"},
+               {BT_PXP_MONITOR_GET_PROPERTY, "BT_PXP_MONITOR_GET_PROPERTY"},
+               {BT_PXP_MONITOR_GET_SUPPORTED_SERIVCES, "BT_PXP_MONITOR_GET_SUPPORTED_SERIVCES"},
+               {BT_PXP_REPORTER_REGISTER, "BT_PXP_REPORTER_REGISTER"},
+               {BT_PXP_REPORTER_UNREGISTER, "BT_PXP_REPORTER_UNREGISTER"},
+               {BT_PXP_REPORTER_GET_PROPERTY, "BT_PXP_REPORTER_GET_PROPERTY"},
+               {BT_TDS_PROVIDER_REGISTER, "BT_TDS_PROVIDER_REGISTER"},
+               {BT_TDS_PROVIDER_UNREGISTER, "BT_TDS_PROVIDER_UNREGISTER"},
+               {BT_TDS_PROVIDER_SET_MANUF_DATA, "BT_TDS_PROVIDER_SET_MANUF_DATA"},
+               {BT_TDS_PROVIDER_CREATE, "BT_TDS_PROVIDER_CREATE"},
+               {BT_TDS_PROVIDER_DESTROY, "BT_TDS_PROVIDER_DESTROY"},
+               {BT_TDS_PROVIDER_SET_TRANSPORT_DATA, "BT_TDS_PROVIDER_SET_TRANSPORT_DATA"},
+               {BT_TDS_SEND_ACTIVATION_RESPONSE, "BT_TDS_SEND_ACTIVATION_RESPONSE"},
+               {BT_TDS_READ_TRANSPORT_DATA, "BT_TDS_READ_TRANSPORT_DATA"},
+               {BT_TDS_ENABLE_CONTROL_POINT, "BT_TDS_ENABLE_CONTROL_POINT"},
+               {BT_TDS_ACTIVATE_CONTROL_POINT, "BT_TDS_ACTIVATE_CONTROL_POINT"},
+               {-1, ""},
+       };
+
+       for (i = 0; bt_functions[i].function != -1; i++) {
+               if (bt_functions[i].function == function)
+                       return bt_functions[i].function_name;
+       }
+
+       return NULL;
+}
+
 void _bt_logging_connection(gboolean connect, int addr_type)
 {
        static int le_conn = 0;
index 4f19add..98da9f8 100644 (file)
@@ -558,12 +558,6 @@ static gboolean __ignore_auto_pairing_request(const char *address)
        }
 
        buffer = g_malloc0(sizeof(char) * size);
-       /* Fix : NULL_RETURNS */
-       if (buffer == NULL) {
-               BT_ERR("Memory allocation error\n");
-               fclose(fp);
-               return FALSE;
-       }
        result = fread((char *)buffer, 1, size, fp);
        fclose(fp);
        if (result != size) {
@@ -1141,12 +1135,6 @@ int _bt_unbond_device(int request_id,
 
        /* allocate user data so that it can be retrieved in callback */
        unbonding_info = g_malloc0(sizeof(bt_funcion_data_t));
-       /* Fix : NULL_RETURNS */
-       if (unbonding_info == NULL) {
-               BT_ERR("Memory not allocated !");
-               return BLUETOOTH_ERROR_MEMORY_ALLOCATION;
-       }
-
        unbonding_info->addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
        unbonding_info->req_id = request_id;
 
@@ -1582,7 +1570,6 @@ int _bt_is_gatt_connected(bluetooth_device_address_t *device_address,
        GDBusProxy *device_proxy;
        GError *error = NULL;
        GVariant *value;
-       GVariant *tmp_value;
        GDBusConnection *conn;
        GVariant *result = NULL;
        int ret = BLUETOOTH_ERROR_NONE;
@@ -1603,8 +1590,9 @@ int _bt_is_gatt_connected(bluetooth_device_address_t *device_address,
        g_free(object_path);
        retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 
-       result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
-                       g_variant_new("(s)", BT_DEVICE_INTERFACE),
+       result = g_dbus_proxy_call_sync(device_proxy, "Get",
+                       g_variant_new("(ss)", BT_DEVICE_INTERFACE,
+                               "GattConnected"),
                        G_DBUS_CALL_FLAGS_NONE,
                        -1,
                        NULL,
@@ -1618,21 +1606,12 @@ int _bt_is_gatt_connected(bluetooth_device_address_t *device_address,
                return BLUETOOTH_ERROR_INTERNAL;
        }
 
-       g_variant_get(result , "(@a{sv})", &value);
+       g_variant_get(result, "(v)", &value);
+       *is_connected = g_variant_get_boolean(value);
        g_variant_unref(result);
 
-       tmp_value = g_variant_lookup_value(value, "GattConnected", G_VARIANT_TYPE_BOOLEAN);
-       if (tmp_value == NULL) {
-               g_object_unref(device_proxy);
-               g_variant_unref(value);
-               return BLUETOOTH_ERROR_INTERNAL;
-       }
-
-       *is_connected = g_variant_get_boolean(tmp_value);
-
        BT_DBG("gatt is connected : %d", *is_connected);
 
-       g_variant_unref(tmp_value);
        g_variant_unref(value);
        g_object_unref(device_proxy);
 
@@ -1782,7 +1761,6 @@ int _bt_get_connected_link(bluetooth_device_address_t *device_address,
        GDBusProxy *device_proxy;
        GError *error = NULL;
        GDBusConnection *conn;
-       GVariant *tmp_value = NULL;
        GVariant *value = NULL;
        GVariant *result = NULL;
 
@@ -1805,33 +1783,24 @@ int _bt_get_connected_link(bluetooth_device_address_t *device_address,
                return BLUETOOTH_ERROR_NONE;
        }
 
-       result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
-                                       g_variant_new("(s)", BT_DEVICE_INTERFACE),
-                                       G_DBUS_CALL_FLAGS_NONE,
-                                       -1,
-                                       NULL,
-                                       &error);
+       result = g_dbus_proxy_call_sync(device_proxy, "Get",
+                       g_variant_new("(ss)", BT_DEVICE_INTERFACE, "Connected"),
+                       G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
 
        if (error != NULL) {
                BT_ERR("Error occured in Proxy call [%s]\n", error->message);
                g_error_free(error);
                g_object_unref(device_proxy);
                return BLUETOOTH_ERROR_INTERNAL;
+       } else {
+               g_variant_get(result, "(v)", &value);
+               *connected = g_variant_get_byte(value);
+               g_variant_unref(value);
+               g_variant_unref(result);
        }
 
-       g_variant_get(result , "(@a{sv})", &value);
-       g_variant_unref(result);
-
-       tmp_value = g_variant_lookup_value(value, "Connected", G_VARIANT_TYPE_BYTE);
-       if (tmp_value != NULL) {
-               *connected = g_variant_get_byte(tmp_value);
-               g_variant_unref(tmp_value);
-               g_object_unref(device_proxy);
-               return BLUETOOTH_ERROR_NONE;
-       } else  {
-               BT_ERR("g_variant value is NULL");
-               return BLUETOOTH_ERROR_INTERNAL;
-       }
+       g_object_unref(device_proxy);
+       return BLUETOOTH_ERROR_NONE;
 }
 
 static void __le_connection_req_cb(GDBusProxy *proxy, GAsyncResult *res,
@@ -1927,12 +1896,6 @@ static int __bt_connect_le_device_internal(int req_id, const bluetooth_device_ad
        retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 
        func_data = g_malloc0(sizeof(bt_function_data_t));
-       if (func_data == NULL) {
-               BT_ERR("Unable to allocate memory for address");
-               ret = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
-               goto fail;
-       }
-
        func_data->address = g_strdup(device_address);
        if (func_data->address == NULL) {
                BT_ERR("Unable to allocate memory for address");
@@ -1957,10 +1920,10 @@ static int __bt_connect_le_device_internal(int req_id, const bluetooth_device_ad
 fail:
        if (device_proxy)
                g_object_unref(device_proxy);
-       if (func_data) {
-               g_free(func_data->address);
-               g_free(func_data);
-       }
+
+       g_free(func_data->address);
+       g_free(func_data);
+
        return ret;
 }
 
@@ -2049,12 +2012,6 @@ int _bt_disconnect_le_device(int req_id,
        retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 
        func_data = g_malloc0(sizeof(bt_function_data_t));
-       if (func_data == NULL) {
-               BT_ERR("Unable to allocate memory for address");
-               ret = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
-               goto fail;
-       }
-
        func_data->address = g_strdup(device_address);
        if (func_data->address == NULL) {
                BT_ERR("Unable to allocate memory for address");
@@ -2078,10 +2035,10 @@ int _bt_disconnect_le_device(int req_id,
 fail:
        if (device_proxy)
                g_object_unref(device_proxy);
-       if (func_data) {
-               g_free(func_data->address);
-               g_free(func_data);
-       }
+
+       g_free(func_data->address);
+       g_free(func_data);
+
        return ret;
 }
 
@@ -3099,10 +3056,8 @@ int _bt_get_att_mtu(bluetooth_device_address_t *device_address,
        GDBusProxy *device_proxy;
        GError *error = NULL;
        GVariant *value;
-       GVariant *tmp_value;
        GDBusConnection *conn;
        GVariant *result = NULL;
-       int ret = BLUETOOTH_ERROR_NONE;
 
        BT_CHECK_PARAMETER(device_address, return);
 
@@ -3120,40 +3075,24 @@ int _bt_get_att_mtu(bluetooth_device_address_t *device_address,
        g_free(object_path);
        retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 
-       result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
-                       g_variant_new("(s)", BT_DEVICE_INTERFACE),
-                       G_DBUS_CALL_FLAGS_NONE,
-                       -1,
-                       NULL,
-                       &error);
-       if (result == NULL) {
-               if (error != NULL) {
-                       BT_ERR("Error occured in Proxy call [%s]\n", error->message);
-                       g_error_free(error);
-               }
+       result = g_dbus_proxy_call_sync(device_proxy, "Get",
+                       g_variant_new("(ss)", BT_DEVICE_INTERFACE, "AttMtu"),
+                       G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+       if (error) {
+               ERR("DBus Error : %s", error->message);
+               g_clear_error(&error);
                g_object_unref(device_proxy);
                return BLUETOOTH_ERROR_INTERNAL;
-       }
-
-       g_variant_get(result , "(@a{sv})", &value);
-       g_variant_unref(result);
-
-       tmp_value = g_variant_lookup_value(value, "AttMtu", G_VARIANT_TYPE_UINT16);
-       if (tmp_value == NULL) {
-               g_object_unref(device_proxy);
+       } else {
+               g_variant_get(result, "(v)", &value);
+               *mtu = g_variant_get_uint16(value);
+               BT_DBG("ATT MTU : %d", *mtu);
                g_variant_unref(value);
-               return BLUETOOTH_ERROR_INTERNAL;
+               g_variant_unref(result);
        }
 
-       *mtu = g_variant_get_uint16(tmp_value);
-
-       BT_DBG("ATT MTU : %d", *mtu);
-
-       g_variant_unref(tmp_value);
-       g_variant_unref(value);
        g_object_unref(device_proxy);
-
-       return ret;
+       return BLUETOOTH_ERROR_NONE;
 }
 
 int _bt_get_device_ida(bluetooth_device_address_t *device_address,
index 0e65149..53af13b 100644 (file)
@@ -2161,8 +2161,6 @@ void _bt_handle_device_event(GVariant *msg, const char *member, const char *path
                ret_if(_bt_is_le_scanning() == FALSE);
 
                le_dev_info = g_malloc0(sizeof(bt_remote_le_dev_info_t));
-               if (le_dev_info == NULL)
-                       return;
 
                g_variant_get(msg, "(syyii@ay)", &le_dev_info->address,
                                                &le_dev_info->addr_type,
@@ -2170,6 +2168,11 @@ void _bt_handle_device_event(GVariant *msg, const char *member, const char *path
                                                &le_dev_info->rssi,
                                                &le_dev_info->adv_data_len,
                                                &value);
+               if (value == NULL) {
+                       _bt_free_le_device_info(le_dev_info);
+                       return;
+               }
+
                _bt_convert_device_path_to_address(path, le_dev_info->address);
 
                buffer_len = g_variant_get_size(value);
@@ -2193,21 +2196,13 @@ void _bt_handle_device_event(GVariant *msg, const char *member, const char *path
 
                if (le_dev_info->adv_type != BT_LE_ADV_SCAN_RSP) {       /* ADV_IND */
                        adv_info = g_malloc0(sizeof(bt_le_adv_info_t));
-                       if (adv_info == NULL) {
-                               _bt_free_le_device_info(le_dev_info);
-                               g_variant_unref(value);
-                               return;
-                       }
-
                        adv_info->addr = g_strdup(le_dev_info->address);
                        adv_info->addr_type = le_dev_info->addr_type;
                        adv_info->rssi = le_dev_info->rssi;
                        adv_info->data_len = le_dev_info->adv_data_len;
                        adv_info->data = g_malloc0(le_dev_info->adv_data_len);
-                       if (adv_info->data) {
-                               memcpy(adv_info->data, le_dev_info->adv_data,
-                                               le_dev_info->adv_data_len);
-                       }
+                       memcpy(adv_info->data, le_dev_info->adv_data,
+                                       le_dev_info->adv_data_len);
 
                        if (__bt_add_adv_ind_info(adv_info) == 0) {
                                adv_info->timer_id = g_timeout_add(1000,
index 681d35c..5fb2214 100755 (executable)
@@ -86,9 +86,6 @@ int _bt_insert_request_list(int req_id, int service_function,
        request_info_t *info;
 
        info = g_malloc0(sizeof(request_info_t));
-       /* Fix : NULL_RETURNS */
-       retv_if(info == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
-
        info->req_id = req_id;
        info->service_function = service_function;
        info->context = context;
index f66958d..e3af264 100644 (file)
@@ -374,6 +374,8 @@ const char *_bt_convert_disc_reason_to_string(int reason);
 
 const char *_bt_convert_profile_state_to_string(bt_profile_state_t state);
 
+const char *_bt_convert_service_function_to_string(int function);
+
 void _bt_logging_connection(gboolean connect, int addr_type);
 
 char *_bt_get_adapter_path(void);