From: DoHyun Pyun Date: Mon, 7 Aug 2017 04:55:42 +0000 (+0900) Subject: Apply tizen 3.0 based product patchsets X-Git-Tag: submit/tizen/20170808.020532^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=1964e11a96b7a85fdf291f86002aaaa4a289281c;p=platform%2Fcore%2Fapi%2Fbluetooth.git Apply tizen 3.0 based product patchsets ------------------------------------------------- commit 4479eac5ecd1d64e09b39d8451522da9f9b335cd Author: Deokhyun Kim Date: Fri Jul 14 18:59:19 2017 +0900 Fix parameter order ------------------------------------------------- Change-Id: If6142828b69022b36df961920c6163cc55c89b1a Signed-off-by: DoHyun Pyun --- diff --git a/include/bluetooth_internal.h b/include/bluetooth_internal.h index 6c2af97..c8836f8 100644 --- a/include/bluetooth_internal.h +++ b/include/bluetooth_internal.h @@ -813,6 +813,34 @@ int bt_adapter_le_set_remote_oob_ext_data(const char *remote_address, */ int bt_adapter_le_set_advertising_filter_policy(bt_advertiser_h advertiser, bt_adapter_le_advertising_filter_policy_e filter_policy); +/** + * @internal + * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE + * @brief Retrieves the address of the devices connected with the specific profile. + * @since_tizen 4.0 + * + * @param[in] profile_uuid The UUID of profile service uuid of the connected device + * @param [in] callback The callback function to invoke + * @param [in] user_data The user data passed from the foreach function + * + * @return 0 on success, otherwise a negative error value. + * @retval #BT_ERROR_NONE Successful + * @retval #BT_ERROR_NOT_INITIALIZED Not initialized + * @retval #BT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #BT_ERROR_OUT_OF_MEMORY Out of memory + * @retval #BT_ERROR_NOT_ENABLED Not enabled + * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED There is no connected device + * @retval #BT_ERROR_OPERATION_FAILED Operation failed + * @retval #BT_ERROR_NOT_SUPPORTED Not supported + * + * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED. + * @post This function invokes bt_adapter_profile_connected_devices_cb(). + * + * @see bt_adapter_profile_connected_devices_cb() + */ +int bt_adapter_foreach_profile_connected_devices(const char *profile_uuid, + bt_adapter_profile_connected_devices_cb callback, void *user_data); + /** * @internal * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE diff --git a/include/bluetooth_type_internal.h b/include/bluetooth_type_internal.h index 08e68a9..a61821b 100644 --- a/include/bluetooth_type_internal.h +++ b/include/bluetooth_type_internal.h @@ -31,6 +31,23 @@ extern "C" * @file bluetooth_type_internal.h */ +#define BT_PROFILE_SERVICE_UUID_SPP "1101" +#define BT_PROFILE_SERVICE_UUID_HSP_HS "1108" +#define BT_PROFILE_SERVICE_UUID_HSP_AG "1112" +#define BT_PROFILE_SERVICE_UUID_OPP "1105" +#define BT_PROFILE_SERVICE_UUID_HFP_HF "111e" +#define BT_PROFILE_SERVICE_UUID_HFP_AG "111f" +#define BT_PROFILE_SERVICE_UUID_A2DP_SOURCE "110a" +#define BT_PROFILE_SERVICE_UUID_A2DP_SINK "110b" +#define BT_PROFILE_SERVICE_UUID_AVRCP_TARGET "110c" +#define BT_PROFILE_SERVICE_UUID_AVRCP_CONTROL "110f" +#define BT_PROFILE_SERVICE_UUID_PAN_PANU "1115" +#define BT_PROFILE_SERVICE_UUID_PAN_NAP "1116" +#define BT_PROFILE_SERVICE_UUID_PAN_GN "1117" +#define BT_PROFILE_SERVICE_UUID_HDP_SOURCE "1401" +#define BT_PROFILE_SERVICE_UUID_HDP_SINK "1402" +#define BT_PROFILE_SERVICE_UUID_HID "1124" + /** * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE * @brief Enumerations of the Bluetooth adapter le state. diff --git a/src/bluetooth-adapter.c b/src/bluetooth-adapter.c index b9ee131..b0e63f5 100644 --- a/src/bluetooth-adapter.c +++ b/src/bluetooth-adapter.c @@ -3879,7 +3879,11 @@ int bt_adapter_le_scan_filter_set_proximity_uuid(bt_scan_filter_h scan_filter) if (ret == BT_ERROR_NONE) ret = bt_adapter_le_scan_filter_register(pxp_linkloss_alert_filter); if (ret != BT_ERROR_NONE) { - bt_adapter_le_scan_filter_unregister(pxp_linkloss_alert_filter); + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + ret = bt_adapter_le_scan_filter_destroy(pxp_linkloss_alert_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } pxp_linkloss_alert_filter = NULL; } } else { @@ -3894,7 +3898,11 @@ int bt_adapter_le_scan_filter_set_proximity_uuid(bt_scan_filter_h scan_filter) if (ret == BT_ERROR_NONE) ret = bt_adapter_le_scan_filter_register(pxp_immediate_alert_filter); if (ret != BT_ERROR_NONE) { - bt_adapter_le_scan_filter_unregister(pxp_immediate_alert_filter); + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + ret = bt_adapter_le_scan_filter_destroy(pxp_immediate_alert_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } pxp_immediate_alert_filter = NULL; } } else { @@ -3909,7 +3917,11 @@ int bt_adapter_le_scan_filter_set_proximity_uuid(bt_scan_filter_h scan_filter) if (ret == BT_ERROR_NONE) ret = bt_adapter_le_scan_filter_register(pxp_signal_loss_filter); if (ret != BT_ERROR_NONE) { - bt_adapter_le_scan_filter_unregister(pxp_signal_loss_filter); + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + ret = bt_adapter_le_scan_filter_destroy(pxp_signal_loss_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } pxp_signal_loss_filter = NULL; } } else { @@ -3929,18 +3941,39 @@ int bt_adapter_le_scan_filter_unset_proximity_uuid(bt_scan_filter_h scan_filter) /* unregister Linkloss alert scan filter */ if (pxp_linkloss_alert_filter) { ret = bt_adapter_le_scan_filter_unregister(pxp_linkloss_alert_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + ret = bt_adapter_le_scan_filter_destroy(pxp_linkloss_alert_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } pxp_linkloss_alert_filter = NULL; } /* unregister Immediate alert scan filter */ if (pxp_immediate_alert_filter) { ret = bt_adapter_le_scan_filter_unregister(pxp_immediate_alert_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + ret = bt_adapter_le_scan_filter_destroy(pxp_immediate_alert_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } pxp_immediate_alert_filter = NULL; } /* unregister Signal loss scan filter */ if (pxp_signal_loss_filter) { ret = bt_adapter_le_scan_filter_unregister(pxp_signal_loss_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + ret = bt_adapter_le_scan_filter_destroy(pxp_signal_loss_filter); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } pxp_signal_loss_filter = NULL; } diff --git a/src/bluetooth-audio.c b/src/bluetooth-audio.c index 928c3be..a5401a3 100644 --- a/src/bluetooth-audio.c +++ b/src/bluetooth-audio.c @@ -1018,6 +1018,41 @@ int bt_hf_notify_voice_recognition_state(bool state) return error; } +int bt_hf_set_vendor_dep_cmd_event_cb(bt_hf_vendor_dep_cmd_event_cb callback, void *user_data) +{ + BT_CHECK_INIT_STATUS(); + BT_CHECK_HF_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(callback); + + _bt_set_cb(BT_EVENT_HF_VENDOR_DEP_CMD_EVENT, callback, user_data); + return BT_ERROR_NONE; +} + +int bt_hf_unset_vendor_dep_cmd_event_cb(void) +{ + BT_CHECK_INIT_STATUS(); + BT_CHECK_HF_INIT_STATUS(); + + if (_bt_check_cb(BT_EVENT_HF_VENDOR_DEP_CMD_EVENT) == true) + _bt_unset_cb(BT_EVENT_HF_VENDOR_DEP_CMD_EVENT); + return BT_ERROR_NONE; +} + +int bt_hf_notify_vendor_cmd(int appid, char *msg) +{ + int error; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_HF_INIT_STATUS(); + + error = bluetooth_hf_send_xsat_cmd(appid, msg); + error = _bt_get_error_code(error); + if (error != BT_ERROR_NONE) + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); + + return error; +} + int bt_hf_set_call_status_updated_event_cb(bt_hf_call_status_updated_event_cb callback, void *user_data) { BT_CHECK_HF_SUPPORT(); diff --git a/src/bluetooth-common.c b/src/bluetooth-common.c index 48f8f92..4742fa3 100644 --- a/src/bluetooth-common.c +++ b/src/bluetooth-common.c @@ -185,6 +185,18 @@ int bt_get_uuid_name(const char *uuid, char **name) {"1810", "Blood Pressure"}, {"1811", "Alert Notification Service"}, {"1812", "Human Interface Device"}, + {"1813", "Scan Parameters"}, + {"1814", "Running Speed and Cadence"}, + {"1815", "Automation IO"}, + {"1816", "Cycling Speed and Cadence"}, + {"1818", "Cycling Power"}, + {"1819", "Location and Navigation"}, + {"181A", "Environmental Sensing"}, + {"181B", "Body Composition"}, + {"181C", "User Data"}, + {"181D", "Weight Scale"}, + {"181E", "Bond Management"}, + {"181F", "Continuous Glucose Monitoring"}, /* GATT Declarations */ {"2800", "Primary Service Declaration"}, @@ -215,8 +227,18 @@ int bt_get_uuid_name(const char *uuid, char **name) {"2A08", "Date Time"}, {"2A09", "Day of Week"}, {"2A0A", "Day Date Time"}, + {"2A11", "Time with DST"}, + {"2A12", "Time Accuracy"}, + {"2A13", "Time Source"}, + {"2A14", "Reference Time Information"}, + {"2A16", "Time Update Control Point"}, + {"2A17", "Time Update State"}, + {"2A18", "Glucose Measurement"}, {"2A19", "Battery Level"}, + {"2A1C", "Temperature Measurement"}, + {"2A1D", "Temperature Type"}, {"2A1E", "Intermediate Temperature"}, + {"2A21", "Measurement Interval"}, {"2A23", "System ID"}, {"2A24", "Model Number String"}, {"2A25", "Serial Number String"}, @@ -226,13 +248,36 @@ int bt_get_uuid_name(const char *uuid, char **name) {"2A29", "Manufacturer Name String"}, {"2A2A", "IEEE 11073-20601 Regulatory Certification Data List"}, {"2A2B", "Current Time"}, + {"2A34", "Glucose Measurement Context"}, + {"2A35", "Blood Pressure Measurement"}, {"2A37", "Heart Rate Measurement"}, {"2A38", "Body Sensor Location"}, + {"2A39", "Heart Rate Control Point"}, {"2A3F", "Alert Status"}, {"2A46", "New Alert"}, + {"2A49", "Blood Pressure Feature"}, {"2A4A", "HID Information"}, {"2A4C", "HID Control Point"}, {"2A50", "PnP ID"}, + {"2A51", "Glucose Feature"}, + {"2A52", "Record Access Control Point"}, + {"2A53", "RSC Measurement"}, + {"2A54", "RSC Feature"}, + {"2A55", "SC Control Point"}, + {"2A56", "Digital"}, + {"2A58", "Analog"}, + {"2A5A", "Aggregate"}, + {"2A5B", "CSC Measurement"}, + {"2A5C", "CSC Feature"}, + {"2A5D", "Sensor Location"}, + {"2A63", "Cycling Power Measurement"}, + {"2A64", "Cycling Power Vector"}, + {"2A65", "Cycling Power Feature"}, + {"2A66", "Cycling Power Control Point"}, + {"2A67", "Location and Speed"}, + {"2A68", "Navigation"}, + {"2A6D", "Pressure"}, + {"2A6E", "Temperature"}, /* Custom uuids */ {"7905F431-B5CE-4E99-A40F-4B1E122D00D0", "Apple Notification Center Service"}, @@ -392,6 +437,13 @@ int _bt_get_error_code(int origin_error) return BT_ERROR_AUTH_REJECTED; case BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION: return BT_ERROR_DEVICE_POLICY_RESTRICTION; +/* Because BLUETOOTH_ERROR_NO_DATA is not defined in Tizen 3.0's bluetooth-api.h, + the build error is occured. We will include all patchsets for this in Tizen 4.0. + In tizen 3.0, we comment out this code for fixing build error. */ +#if 0 + case BLUETOOTH_ERROR_NO_DATA: + return BT_ERROR_NO_DATA; +#endif case BLUETOOTH_ERROR_PARING_FAILED: case BLUETOOTH_ERROR_MAX_CONNECTION: case BLUETOOTH_ERROR_REGISTRATION_FAILED: @@ -774,7 +826,28 @@ static int __bt_get_bt_device_connection_info_s(bt_device_connection_info_s **de break; } - (*dest)->disconn_reason = source->disc_reason; + switch (source->disc_reason) { +/* After ACR for BT_DEVICE_DISCONNECT_REASON_AUTH_FAILED, will enable this code */ +#if 0 + case (int)BLUETOOTH_ERROR_AUTH_FAILURE: + (*dest)->disconn_reason = BT_DEVICE_DISCONNECT_REASON_AUTH_FAILED; + break; +#endif + case (int)BLUETOOTH_ERROR_CONNECTION_TIMEOUT: + (*dest)->disconn_reason = BT_DEVICE_DISCONNECT_REASON_TIMEOUT; + break; + case (int)BLUETOOTH_ERROR_REMOTE_USER_TERM: + case (int)BLUETOOTH_ERROR_REMOTE_LOW_RESOURCES: + case (int)BLUETOOTH_ERROR_REMOTE_POWER_OFF: + (*dest)->disconn_reason = BT_DEVICE_DISCONNECT_REASON_REMOTE; + break; + case (int)BLUETOOTH_ERROR_LOCAL_HOST_TERM: + (*dest)->disconn_reason = BT_DEVICE_DISCONNECT_REASON_LOCAL_HOST; + break; + default: + (*dest)->disconn_reason = BT_DEVICE_DISCONNECT_REASON_UNKNOWN; + break; + } return BT_ERROR_NONE; } @@ -1062,16 +1135,12 @@ static bool __bt_need_to_handle(int event) event_index = __bt_get_cb_index(event); if (event_index != -1 && bt_event_slot_container[event_index].callback) return true; - else - BT_DBG("Event [%d] would not handled, not found in bt_event_slot_container", event); return false; } static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *user_data) { - BT_DBG("Entered for event: %d", event); - int call_id; int *avrcp_mode; int *discoverable_timeout; @@ -1347,6 +1416,7 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us else error_code = _bt_get_error_code(param->result); + memset(&rfcomm_connection, 0x00, sizeof(bt_socket_connection_s)); connection_ind = (bluetooth_rfcomm_connection_t *)(param->param_data); if (connection_ind) { @@ -1380,6 +1450,7 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED: BT_INFO("bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_DISCONNECTED"); + memset(&rfcomm_connection, 0x00, sizeof(bt_socket_connection_s)); disconnection_ind = (bluetooth_rfcomm_disconnection_t *)(param->param_data); if (disconnection_ind) { @@ -2056,14 +2127,16 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us char_val = (bt_gatt_char_value_t *)(param->param_data); if (TIZEN_FEATURE_ENABLE_LEGACY_GATT_CLIENT && _bt_gatt_is_legacy_client_mode()) { - bt_gatt_char_value_t *char_val = param->param_data; + if (_bt_gatt_is_legacy_client_mode()) { + bt_gatt_char_value_t *char_val = param->param_data; - if (char_val == NULL) - return; - ((bt_gatt_characteristic_changed_cb)bt_event_slot_container[event_index].callback) - (char_val->char_handle, char_val->char_value, char_val->val_len, - bt_event_slot_container[event_index].user_data); - break; + if (char_val == NULL) + return; + ((bt_gatt_characteristic_changed_cb)bt_event_slot_container[event_index].callback) + (char_val->char_handle, char_val->char_value, char_val->val_len, + bt_event_slot_container[event_index].user_data); + break; + } } if (char_val == NULL) return; @@ -2081,13 +2154,15 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us BT_INFO("BLUETOOTH_EVENT_GATT_READ_CHAR"); if (TIZEN_FEATURE_ENABLE_LEGACY_GATT_CLIENT && _bt_gatt_is_legacy_client_mode()) { - bt_gatt_char_value_t *char_val = param->param_data; + if (_bt_gatt_is_legacy_client_mode()) { + bt_gatt_char_value_t *char_val = param->param_data; - ((bt_gatt_characteristic_read_cb)bt_event_slot_container[event_index].callback) - (char_val->char_value, char_val->val_len, - bt_event_slot_container[event_index].user_data); - _bt_unset_cb(BT_EVENT_GATT_CLIENT_READ_CHARACTERISTIC_LEGACY); - break; + ((bt_gatt_characteristic_read_cb)bt_event_slot_container[event_index].callback) + (char_val->char_value, char_val->val_len, + bt_event_slot_container[event_index].user_data); + _bt_unset_cb(BT_EVENT_GATT_CLIENT_READ_CHARACTERISTIC_LEGACY); + break; + } } _bt_unset_cb(BT_EVENT_GATT_CLIENT_READ_CHARACTERISTIC); ret = param->result; @@ -2109,11 +2184,13 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us BT_INFO("BLUETOOTH_EVENT_GATT_WRITE_CHAR"); if (TIZEN_FEATURE_ENABLE_LEGACY_GATT_CLIENT && _bt_gatt_is_legacy_client_mode()) { - ((bt_gatt_characteristic_write_cb)bt_event_slot_container[event_index].callback) - (bt_event_slot_container[event_index].user_data); + if (_bt_gatt_is_legacy_client_mode()) { + ((bt_gatt_characteristic_write_cb)bt_event_slot_container[event_index].callback) + (bt_event_slot_container[event_index].user_data); - _bt_unset_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC_LEGACY); - break; + _bt_unset_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC_LEGACY); + break; + } } _bt_unset_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC); @@ -2202,7 +2279,7 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us } cb(value_change->address, value_change->req_id, value_change->service_handle, - gatt_handle, value_change->response_needed, value_change->offset, + gatt_handle, (bool)value_change->response_needed, value_change->offset, (char *)value_change->att_value, value_change->val_len, user_data); break; } diff --git a/src/bluetooth-hid.c b/src/bluetooth-hid.c index 8c1e529..acb2001 100644 --- a/src/bluetooth-hid.c +++ b/src/bluetooth-hid.c @@ -28,6 +28,9 @@ static bool is_hid_host_initialized = false; +#define HID_MOUSE_REPORT_ID 1 +#define HID_KEY_REPORT_ID 2 + #define BT_CHECK_HID_HOST_SUPPORT() \ { \ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON); \ @@ -221,6 +224,8 @@ int bt_hid_device_send_mouse_event(const char *remote_address, const bt_hid_mouse_data_s *mouse_data) { int ret; + hid_send_mouse_event_t mouse_event = {0, }; + BT_CHECK_HID_DEVICE_SUPPORT(); BT_CHECK_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(remote_address); @@ -243,8 +248,16 @@ int bt_hid_device_send_mouse_event(const char *remote_address, return -1; } + mouse_event.btcode = 0xA1; + mouse_event.rep_id = HID_MOUSE_REPORT_ID; + + mouse_event.button = (unsigned char)mouse_data->buttons; + mouse_event.axis_x = (signed char)mouse_data->axis_x; + mouse_event.axis_y = (signed char)mouse_data->axis_y; + mouse_event.axis_z = (signed char)mouse_data->padding; + ret = bluetooth_hid_device_send_mouse_event(remote_address, - *(hid_send_mouse_event_t *)mouse_data); + mouse_event); if (ret <= 0) { if (ret == -1) { /* write fail case */ @@ -275,6 +288,8 @@ int bt_hid_device_send_key_event(const char *remote_address, BT_CHECK_INPUT_PARAMETER(key_data); hid_send_key_event_t send_event = {0}; + send_event.btcode = 0xA1; + send_event.rep_id = HID_KEY_REPORT_ID; send_event.modify = key_data->modifier; memcpy(send_event.key, key_data->key, sizeof(send_event.key)); diff --git a/src/bluetooth-tds.c b/src/bluetooth-tds.c index 4c19921..5bade3c 100644 --- a/src/bluetooth-tds.c +++ b/src/bluetooth-tds.c @@ -239,7 +239,7 @@ int bt_tds_provider_set_transport_data(bt_tds_provider_h provider, if (!tds_provider_registered) return BT_ERROR_NOT_INITIALIZED; - if (BLUETOOTH_TDS_DATA_LENGTH_MAX < length) { + if (0 >= length || BLUETOOTH_TDS_DATA_LENGTH_MAX < length) { error_code = BT_ERROR_INVALID_PARAMETER; BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); return error_code; @@ -641,6 +641,9 @@ int _bt_tds_parse_transport_blocks(bt_tds_transport_block_list_s **info, static void __bt_tds_reset_seeker_data(bt_tds_seeker_s *seeker) { + g_free((seeker)->remote_address); + (seeker)->remote_address = NULL; + g_free((seeker)->tds_control_point); (seeker)->tds_control_point = NULL; @@ -1062,11 +1065,13 @@ int bt_tds_seeker_create(const char *remote_address, bt_tds_seeker_h *seeker) if (seeker_s->connected == true) { error_code = __bt_update_tds_transport_data(&addr_hex, seeker_s); if (error_code != BLUETOOTH_ERROR_NONE) { + __bt_tds_reset_seeker_data(seeker_s); g_free(seeker_s); return BT_ERROR_OPERATION_FAILED; } error_code = bluetooth_gatt_set_service_change_watcher(&addr_hex, true); if (error_code != BLUETOOTH_ERROR_NONE) { + __bt_tds_reset_seeker_data(seeker_s); g_free(seeker_s); return BT_ERROR_OPERATION_FAILED; } @@ -1074,6 +1079,7 @@ int bt_tds_seeker_create(const char *remote_address, bt_tds_seeker_h *seeker) seeker_s->remote_address = g_strdup(remote_address); if (seeker_s->remote_address == NULL) { + __bt_tds_reset_seeker_data(seeker_s); free(seeker_s); error_code = BT_ERROR_OUT_OF_MEMORY; BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); diff --git a/test/bt_unit_test.c b/test/bt_unit_test.c index bfc2d7e..2ca22e6 100644 --- a/test/bt_unit_test.c +++ b/test/bt_unit_test.c @@ -216,6 +216,8 @@ tc_table_t tc_adapter[] = { , BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING}, {"bt_adapter_foreach_bonded_device" , BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE}, + {"bt_adapter_foreach_profile_connected_devices" + , BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_PROFILE_CONNECTED_DEVICES}, {"bt_adapter_get_bonded_device_info" , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO}, {"bt_adapter_is_service_used" @@ -1294,6 +1296,12 @@ void tc_usage_print(void) __bt_initialize_all(); TC_PRT("Key 0 : usage BACK"); return; + case BT_UNIT_TEST_TABLE_TDS_PROVIDER: + tc_table = tc_tds_provider; + break; + case BT_UNIT_TEST_TABLE_TDS_SEEKER: + tc_table = tc_tds_seeker; + break; case BT_UNIT_TEST_TABLE_OTP: tc_table = tc_otp; break; @@ -1388,6 +1396,9 @@ static const char *__bt_get_error_message(bt_error_e err) case BT_ERROR_SERVICE_NOT_FOUND: err_str = "BT_ERROR_SERVICE_NOT_FOUND"; break; + case BT_ERROR_NO_DATA: + err_str = "BT_ERROR_NO_DATA"; + break; case BT_ERROR_NOT_SUPPORTED: err_str = "BT_ERROR_NOT_SUPPORTED"; break; @@ -1555,16 +1566,23 @@ static bool __bt_adapter_bonded_device_cb(bt_device_info_s *device_info, void *user_data) { int i; + char *str = NULL; TC_PRT("remote_address: %s", device_info->remote_address); TC_PRT("remote_name: %s", device_info->remote_name); + TC_PRT("is_connected: %d", device_info->is_connected); TC_PRT("service_count: %d", device_info->service_count); if (device_info->service_uuid == NULL) { TC_PRT("No uuids"); } else { - for (i = 0; i < device_info->service_count; i++) - TC_PRT("uuid: %s", device_info->service_uuid[i]); + for (i = 0; i < device_info->service_count; i++) { + bt_get_uuid_name(device_info->service_uuid[i], &str); + + TC_PRT("[%d / %d] %s (%s)", i, device_info->service_count, + str ? str : "Unknown", device_info->service_uuid[i]); + g_free(str); + } } if (device_info->manufacturer_data_len > 0) { @@ -1575,6 +1593,15 @@ static bool __bt_adapter_bonded_device_cb(bt_device_info_s *device_info, printf("%02x ", device_info->manufacturer_data[i]); printf("]\n"); } + printf("\n"); + + return true; +} + +static bool __bt_adapter_profile_connected_devices_cb( + const char *remote_address, void *user_data) +{ + TC_PRT("remote_address: %s", remote_address); return true; } @@ -1777,18 +1804,12 @@ static void __bt_adapter_le_device_discovery_state_changed_cb(int result, discovery_info->rssi, discovery_info->address_type); - if (discovery_info->adv_data_len > 31 || - discovery_info->scan_data_len > 31) { - TC_PRT("###################"); - bt_adapter_le_stop_device_discovery(); - TC_PRT("###################"); - return; - } #if 0 /* LE ADV information */ int i, ret; int field_len = 0; unsigned char *field_data; + printf("Adv data ["); for (i = 0; i < discovery_info->adv_data_len; i++) printf("%02x ", discovery_info->adv_data[i]); @@ -1873,6 +1894,7 @@ static void __bt_hid_device_data_received_cb(const bt_hid_device_received_data_s TC_PRT("+"); char val = 0x01; int ret = 0; + static char hidmode = 0x01; if (data == NULL) { TC_PRT("No received data"); return; @@ -1893,19 +1915,32 @@ static void __bt_hid_device_data_received_cb(const bt_hid_device_received_data_s case BT_HID_HEADER_GET_REPORT: TC_PRT("GET_REPORT data"); TC_PRT("ReportId %d", data->data[1]); - bt_hid_key_data_s send_data; - /* Will send character 'a' */ - char pressedkey[8] = { 4, 0, 0, 0, 0, 0, 0, 0 }; - memcpy(send_data.key, pressedkey, 8); - send_data.modifier = 0; + if (data->data[1] == 0x02) { - ret = bt_hid_device_reply_to_report(remote_addr, - BT_HID_HEADER_GET_REPORT, - BT_HID_PARAM_DATA_RTYPE_INPUT, - (const char *)&send_data, - sizeof(send_data)); + bt_hid_key_data_s send_data; + /* Will send character 'a' */ + char pressedkey[8] = { 4, 0, 0, 0, 0, 0, 0, 0 }; + memcpy(send_data.key, pressedkey, 8); + send_data.modifier = 0; + ret = bt_hid_device_reply_to_report(remote_addr, + BT_HID_HEADER_GET_REPORT, + BT_HID_PARAM_DATA_RTYPE_INPUT, + (const char *)&send_data, + sizeof(send_data)); } else if (data->data[1] == 0x01) { TC_PRT("Send Mouse Event"); + bt_hid_mouse_data_s send_data; + + send_data.buttons = 1; + send_data.padding = BT_HID_MOUSE_BUTTON_NONE; + + send_data.axis_x = 10; + send_data.axis_y = 0; + ret = bt_hid_device_reply_to_report(remote_addr, + BT_HID_HEADER_GET_REPORT, + BT_HID_PARAM_DATA_RTYPE_INPUT, + (const char *)&send_data, + sizeof(send_data)); } else { TC_PRT("Invalid ReportId"); val = BT_HID_HANDSHAKE_ERR_INVALID_REPORT_ID; @@ -1918,21 +1953,35 @@ static void __bt_hid_device_data_received_cb(const bt_hid_device_received_data_s break; case BT_HID_HEADER_SET_REPORT: TC_PRT("SET_REPORT data"); + val = BT_HID_HANDSHAKE_SUCCESSFUL; + ret = bt_hid_device_reply_to_report(remote_addr, + BT_HID_HEADER_HANDSHAKE, + BT_HID_PARAM_DATA_RTYPE_INPUT, + &val, sizeof(val)); + TC_PRT("ret %d", ret); break; case BT_HID_HEADER_DATA: TC_PRT("TRANs DATA"); break; case BT_HID_HEADER_GET_PROTOCOL: - TC_PRT("GET PROTOCOL"); + TC_PRT("GET PROTOCOL %x", hidmode); ret = bt_hid_device_reply_to_report(remote_addr, BT_HID_HEADER_GET_PROTOCOL, BT_HID_PARAM_DATA_RTYPE_INPUT, - &val, sizeof(val)); + &hidmode, sizeof(hidmode)); TC_PRT("ret %d", ret); break; case BT_HID_HEADER_SET_PROTOCOL: TC_PRT("SET PROTOCOL"); val = BT_HID_HANDSHAKE_SUCCESSFUL; + + if (data->data[0] & 0x01) { + TC_PRT("HID Report mode set"); + hidmode = 0x01; + } else { + TC_PRT("HID Boot mode set"); + hidmode = 0x00; + } ret = bt_hid_device_reply_to_report(remote_addr, BT_HID_HEADER_HANDSHAKE, BT_HID_PARAM_DATA_RTYPE_INPUT, @@ -2173,13 +2222,22 @@ void __bt_print_repeat_test_final_summary() void __bt_gatt_connection_state_changed_cb(int result, bool connected, const char *remote_address, void *user_data) { - TC_PRT("result: %s", __bt_get_error_message(result)); + if (result != BT_ERROR_NONE) + TC_PRT("result: %s", __bt_get_error_message(result)); + if (connected) { - TC_PRT("LE connected(address = %s)", remote_address); - /* Fix : STRING_OVERFLOW */ + TC_PRT("GATT connected [%s]", remote_address); strncpy(remote_addr, remote_address, strlen(remote_addr)); + + bt_le_conn_update_s param; + + param.interval_min = 90; + param.interval_max = 90; + param.latency = 0; + param.time_out = 2000; + bt_device_le_conn_update(remote_addr, ¶m); } else { - TC_PRT("LE DISconnected"); + TC_PRT("GATT DISconnected [%s]", remote_address); } } @@ -2187,9 +2245,11 @@ void __bt_hps_connection_state_changed_cb(int result, bool connected, const char *remote_address, void *user_data) { int ret; - TC_PRT("result: %s", __bt_get_error_message(result)); + if (result != BT_ERROR_NONE) + TC_PRT("result: %s", __bt_get_error_message(result)); + if (connected) { - TC_PRT("HPS connected(address = %s)", remote_address); + TC_PRT("HPS connected [%s]", remote_address); /* Fix : STRING_OVERFLOW */ strncpy(remote_addr, remote_address, strlen(remote_addr)); if (hps_client) { @@ -2201,7 +2261,7 @@ void __bt_hps_connection_state_changed_cb(int result, __bt_get_error_message(ret)); } else { - TC_PRT("HPS DISconnected"); + TC_PRT("HPS DISconnected [%s]", remote_address); } } @@ -3360,6 +3420,14 @@ static void __bt_initialize_all(void) __bt_device_bond_destroyed_cb, NULL); if (ret != BT_ERROR_NONE) TC_PRT("returns %s\n", __bt_get_error_message(ret)); + ret = bt_device_set_connection_state_changed_cb( + __bt_device_connection_state_changed_cb, NULL); + if (ret != BT_ERROR_NONE) + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + ret = bt_device_set_att_mtu_changed_cb( + __bt_device_att_mtu_changed_cb, NULL); + if (ret != BT_ERROR_NONE) + TC_PRT("returns %s\n", __bt_get_error_message(ret)); ret = bt_gatt_set_connection_state_changed_cb( __bt_gatt_connection_state_changed_cb, NULL); if (ret != BT_ERROR_NONE) @@ -3400,6 +3468,34 @@ int test_set_params(int test_id, char *param) switch (current_tc_table) { case BT_UNIT_TEST_TABLE_ADAPTER: { switch (test_id) { + case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY: { + if (param_index == 0) { + g_test_param.param_count = 1; + g_test_param.params = g_malloc0(sizeof(char*) * g_test_param.param_count); + param_type = BT_UNIT_TEST_PARAM_TYPE_INT; + } + + if (param_index > 0) { + g_test_param.params[param_index - 1] = g_malloc0(strlen(param) + 1); + strncpy(g_test_param.params[param_index - 1], param, strlen(param)); + } + + if (param_index == g_test_param.param_count) { + need_to_set_params = false; +#ifdef ARCH64 + test_input_callback((void *)(uintptr_t)test_id); +#else + test_input_callback((void *)test_id); +#endif + param_index = 0; + return 0; + } + + TC_PRT("Input param(%d) (non-discoverable: -1, always: 0, limited-discoverable(time): N)", param_index + 1); + param_index++; + + break; + } case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE: { if (param_index == 0) { g_test_param.param_count = 1; @@ -3686,6 +3782,35 @@ int test_set_params(int test_id, char *param) break; } + case BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION_MODE: { + if (param_index == 0) { + g_test_param.param_count = 1; + g_test_param.params = g_malloc0(sizeof(char*) * g_test_param.param_count); + param_type = BT_UNIT_TEST_PARAM_TYPE_INT; + } + + if (param_index > 0) { + g_test_param.params[param_index - 1] = g_malloc0(strlen(param) + 1); + strncpy(g_test_param.params[param_index - 1], param, strlen(param)); + } + + if (param_index == g_test_param.param_count) { + need_to_set_params = false; +#ifdef ARCH64 + test_input_callback((void *)(uintptr_t)test_id); +#else + test_input_callback((void *)test_id); +#endif + param_index = 0; + return 0; + } + + TC_PRT("Input param(%d) mode (0 : balanced, 1 : low latency, 2 : low power) : %s", param_index + 1, param_type); + param_index++; + + break; + } + case BT_UNIT_TEST_FUNCTION_DEVICE_REQUEST_ATT_MTU: { if (param_index == 0) { g_test_param.param_count = 1; @@ -4059,15 +4184,16 @@ int test_set_params(int test_id, char *param) break; } - case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_READ_VALUE: { + case BT_UNIT_TEST_FUNCTION_GATT_SET_WRITE_TYPE: { if (param_index == 0) { g_test_param.param_count = 3; - g_test_param.params = g_malloc0(sizeof(char *) *g_test_param.param_count); + g_test_param.params = g_malloc0(sizeof(char*) *g_test_param.param_count); + param_type = BT_UNIT_TEST_PARAM_TYPE_STRING; } if (param_index > 0) { int len = strlen(param); - g_test_param.params[param_index - 1] = g_malloc0(len + 1); + g_test_param.params[param_index - 1] = g_malloc0(strlen(param) + 1); /* Remove new line character */ param[len - 1] = '\0'; strncpy(g_test_param.params[param_index - 1], param, strlen(param)); @@ -4092,7 +4218,7 @@ int test_set_params(int test_id, char *param) TC_PRT("Input Characteristic UUID"); break; case 2: - TC_PRT("Input Descriptor UUID or nothing"); + TC_PRT("Input write_type (0 : no response, 1 : with reponse, 2 : signed)"); break; } @@ -4100,9 +4226,9 @@ int test_set_params(int test_id, char *param) break; } - case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_WRITE_VALUE: { + case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_READ_VALUE: { if (param_index == 0) { - g_test_param.param_count = 5; + g_test_param.param_count = 3; g_test_param.params = g_malloc0(sizeof(char *) *g_test_param.param_count); } @@ -4121,7 +4247,6 @@ int test_set_params(int test_id, char *param) #else test_input_callback((void *)test_id); #endif - param_index = 0; return 0; } @@ -4136,27 +4261,23 @@ int test_set_params(int test_id, char *param) case 2: TC_PRT("Input Descriptor UUID or nothing"); break; - case 3: - TC_PRT("Input Value Type (avail. : uint8, uint16, uint32, int8, int16, int32, str)"); - break; - case 4: - TC_PRT("Input Value"); - break; } param_index++; break; } - case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_REQUEST_ATT_MTU: { + case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_WRITE_VALUE: { if (param_index == 0) { - g_test_param.param_count = 1; - g_test_param.params = g_malloc0(sizeof(char*) * g_test_param.param_count); - param_type = "int(1, 2, 10, ...., 512)"; + g_test_param.param_count = 5; + g_test_param.params = g_malloc0(sizeof(char *) *g_test_param.param_count); } if (param_index > 0) { - g_test_param.params[param_index - 1] = g_malloc0(strlen(param) + 1); + int len = strlen(param); + g_test_param.params[param_index - 1] = g_malloc0(len + 1); + /* Remove new line character */ + param[len - 1] = '\0'; strncpy(g_test_param.params[param_index - 1], param, strlen(param)); } @@ -4167,11 +4288,29 @@ int test_set_params(int test_id, char *param) #else test_input_callback((void *)test_id); #endif + param_index = 0; return 0; } - TC_PRT("Input param(%d) : %s", param_index + 1, param_type); + switch (param_index) { + case 0: + TC_PRT("Input Service UUID"); + break; + case 1: + TC_PRT("Input Characteristic UUID"); + break; + case 2: + TC_PRT("Input Descriptor UUID or nothing"); + break; + case 3: + TC_PRT("Input Value Type (avail. : uint8, uint16, uint32, int8, int16, int32, str)"); + break; + case 4: + TC_PRT("Input Value"); + break; + } + param_index++; break; @@ -4857,10 +4996,36 @@ int test_set_params(int test_id, char *param) } case BT_UNIT_TEST_TABLE_HF: - if (!TIZEN_PROFILE_WEARABLE_IVI) - goto __default__; { switch (test_id) { + case BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_WITH_PARAM: { + if (param_index == 0) { + g_test_param.param_count = 1; + g_test_param.params = g_malloc0(sizeof(char*) * g_test_param.param_count); + param_type = BT_UNIT_TEST_PARAM_TYPE_INT; + } + + if (param_index > 0) { + g_test_param.params[param_index - 1] = g_malloc0(strlen(param) + 1); + strncpy(g_test_param.params[param_index - 1], param, strlen(param)); + } + + if (param_index == g_test_param.param_count) { + need_to_set_params = false; +#ifdef ARCH64 + test_input_callback((void *)(uintptr_t)test_id); +#else + test_input_callback((void *)test_id); +#endif + param_index = 0; + return 0; + } + + TC_PRT("Input param(%d) type:%s", param_index + 1, param_type); + param_index++; + + break; + } default: TC_PRT("There is no param to set\n"); need_to_set_params = false; @@ -5170,6 +5335,21 @@ int test_input_callback(void *data) TC_PRT("returns %s\n", __bt_get_error_message(ret)); break; } + case BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_PROFILE_CONNECTED_DEVICES: { + ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_SPP, + __bt_adapter_profile_connected_devices_cb, NULL); + TC_PRT("SPP connected devices returns %s\n", __bt_get_error_message(ret)); + ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_HFP_HF, + __bt_adapter_profile_connected_devices_cb, NULL); + TC_PRT("HFP HF connected devices returns %s\n", __bt_get_error_message(ret)); + ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_A2DP_SOURCE, + __bt_adapter_profile_connected_devices_cb, NULL); + TC_PRT("A2DP Source connected devices returns %s\n", __bt_get_error_message(ret)); + ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_AVRCP_CONTROL, + __bt_adapter_profile_connected_devices_cb, NULL); + TC_PRT("AVRCP Control connected devices returns %s\n", __bt_get_error_message(ret)); + break; + } case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO: { bt_device_info_s *device_info = NULL; @@ -5203,6 +5383,26 @@ int test_input_callback(void *data) TC_PRT("time: %d", time); break; } + case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY: { + int mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE; + int timeout_sec = 0; + + if (g_test_param.param_count > 0) { + if (g_test_param.params[0][0] == '-') + mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + else if (g_test_param.params[0][0] == '0') + mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE; + else { + mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE; + timeout_sec = atoi(g_test_param.params[0]); + } + __bt_free_test_param(&g_test_param); + } + + ret = bt_adapter_set_visibility(mode, timeout_sec); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB: ret = bt_adapter_set_device_discovery_state_changed_cb( __bt_adapter_device_discovery_state_changed_cb, NULL); @@ -5595,6 +5795,7 @@ int test_input_callback(void *data) const char *heart_rate_svc_uuid_16 = "180d"; const char *lmmediate_alert_svc_uuid_16 = "1802"; const char *ancs_uuid_128 = "7905F431-B5CE-4E99-A40F-4B1E122D00D0"; + const char *ams_uuid_128 = "89D3502B-0F36-433A-8EF4-C502AD55F8DC"; int appearance = 192; /* 192 is generic watch */ advertiser = advertiser_list[advertiser_index]; @@ -5713,6 +5914,24 @@ int test_input_callback(void *data) return 0; + case 5: /* AMS */ + ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser, + BT_ADAPTER_LE_PACKET_ADVERTISING, time_svc_uuid_16); + if (ret != BT_ERROR_NONE) + TC_PRT("add service_solicitation_uuid [0x%04x]", ret); + + ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser, + BT_ADAPTER_LE_PACKET_ADVERTISING, ams_uuid_128); + if (ret != BT_ERROR_NONE) + TC_PRT("add service_solicitation_uuid [0x%04x]", ret); + + ret = bt_adapter_le_set_advertising_device_name(advertiser, + BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, true); + if (ret != BT_ERROR_NONE) + TC_PRT("set device name [0x%04x]", ret); + + return 0; + default: TC_PRT("No adv data"); break; @@ -5810,14 +6029,14 @@ int test_input_callback(void *data) else cb = __bt_adapter_le_advertising_state_changed_cb_3; advertiser = advertiser_list[advertiser_index]; + advertiser_index++; + advertiser_index %= 3; if (advertiser == NULL) { ret = bt_adapter_le_create_advertiser(&advertiser); TC_PRT("created le advertiser(%d)", ret); advertiser_list[advertiser_index] = advertiser; } - advertiser_index++; - advertiser_index %= 3; TC_PRT("advertiser: %p", advertiser); @@ -5837,6 +6056,8 @@ int test_input_callback(void *data) else cb = __bt_adapter_le_advertising_state_changed_cb_3; advertiser = advertiser_list[advertiser_index]; + advertiser_index++; + advertiser_index %= 3; adv_params.interval_min = 500; adv_params.interval_max = 500; @@ -5846,8 +6067,6 @@ int test_input_callback(void *data) TC_PRT("created le advertiser(%d)", ret); advertiser_list[advertiser_index] = advertiser; } - advertiser_index++; - advertiser_index %= 3; ret = bt_adapter_le_start_advertising(advertiser, &adv_params, cb, NULL); @@ -5863,24 +6082,9 @@ int test_input_callback(void *data) __bt_free_test_param(&g_test_param); } - if (slot_id < 0 || slot_id >= 3) { - TC_PRT("Invalid slot id: %d", slot_id); - break; - } - advertiser = advertiser_list[slot_id]; - TC_PRT("advertiser: %p", advertiser); - ret = bt_adapter_le_stop_advertising(advertiser); - - if (advertiser_index > 0) - advertiser_index--; - else - advertiser_index = 2; - - advertiser_list[slot_id] = NULL; - if (ret < BT_ERROR_NONE) TC_PRT("failed with [0x%04x]", ret); break; @@ -6043,6 +6247,32 @@ int test_input_callback(void *data) break; } + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_MANUFACTURER_DATA: { + bt_scan_filter_h scan_filter = NULL; + int manufacturer_id = 117; /* samsung */ + char data[] = {0x2, 0x2, 0x2, 0x2}; + /* Use "appearance & tx power level" of bt_adapter_le_add_XXX_advertising_data */ + + ret = bt_adapter_le_scan_filter_create(&scan_filter); + if (ret != BT_ERROR_NONE) + TC_PRT("failed with [0x%04x]", ret); + + ret = bt_adapter_le_scan_filter_set_manufacturer_data(scan_filter, + manufacturer_id, data, sizeof(data)); + if (ret != BT_ERROR_NONE) + TC_PRT("failed with [0x%04x]", ret); + + ret = bt_adapter_le_scan_filter_register(scan_filter); + if (ret != BT_ERROR_NONE) + TC_PRT("failed with [0x%04x]", ret); + + ret = bt_adapter_le_scan_filter_destroy(scan_filter); + if (ret != BT_ERROR_NONE) + TC_PRT("failed with [0x%04x]", ret); + + break; + } + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_IBEACON_DATA: { bt_scan_filter_h scan_filter; @@ -6317,6 +6547,25 @@ int test_input_callback(void *data) TC_PRT("returns %s\n", __bt_get_error_message(ret)); break; } + + case BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION: { + bt_le_conn_update_s param; + + if (g_test_param.param_count == 0) + break; + + param.interval_min = atof(g_test_param.params[0]); + param.interval_max = atof(g_test_param.params[1]); + param.latency = atoi(g_test_param.params[2]); + param.time_out = atoi(g_test_param.params[3]); + + __bt_free_test_param(&g_test_param); + + ret = bt_device_le_conn_update(remote_addr, ¶m); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS: need_to_set_params = true; TC_PRT("Select the function again"); @@ -6882,6 +7131,43 @@ int test_input_callback(void *data) TC_PRT("returns %s\n", __bt_get_error_message(ret)); break; } + case BT_UNIT_TEST_FUNCTION_GATT_SET_WRITE_TYPE: { + char *svc_uuid = NULL; + char *chr_uuid = NULL; + bt_gatt_h svc = NULL; + bt_gatt_h chr = NULL; + bt_gatt_write_type_e write_type; + + if (g_test_param.param_count < 3) { + TC_PRT("Input parameters first"); + break; + } + + svc_uuid = g_test_param.params[0]; + chr_uuid = g_test_param.params[1]; + + ret = bt_gatt_client_get_service(client, svc_uuid, &svc); + if (ret != BT_ERROR_NONE) { + TC_PRT("bt_gatt_client_get_service is failed : %d", ret); + __bt_free_test_param(&g_test_param); + break; + } + + ret = bt_gatt_service_get_characteristic(svc, chr_uuid, &chr); + if (ret != BT_ERROR_NONE) { + TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret); + __bt_free_test_param(&g_test_param); + break; + } + + write_type = atoi(g_test_param.params[2]); + ret = bt_gatt_characteristic_set_write_type(chr, write_type); + if (ret != BT_ERROR_NONE) + TC_PRT("bt_gatt_characteristic_set_write_type is failed : %d", ret); + + __bt_free_test_param(&g_test_param); + break; + } case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_CREATE: { if (client) { bt_gatt_client_destroy(client); @@ -7609,6 +7895,13 @@ int test_input_callback(void *data) } ret = bt_gatt_set_value(custom_h.chr, char_value, 4); TC_PRT("returns %s\n", __bt_get_error_message(ret)); + + /* notify only client remote_addr */ + ret = bt_gatt_server_notify_characteristic_changed_value(custom_h.chr, + __bt_gatt_server_notification_sent_cb, remote_addr, NULL); + TC_PRT("bt_gatt_server_notify_characteristic_changed_value : %s\n", + __bt_get_error_message(ret)); + break; } case BT_UNIT_TEST_FUNCTION_GATT_START_SERVER: { @@ -8730,6 +9023,32 @@ int test_input_callback(void *data) break; } + case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT_SCROLL: { + bt_hid_mouse_data_s send_data; + + send_data.buttons = BT_HID_MOUSE_BUTTON_NONE; + send_data.padding = 0x01; + + send_data.axis_x = 0; + send_data.axis_y = 0; + TC_PRT("Scroll UP"); + ret = bt_hid_device_send_mouse_event(remote_addr, &send_data); + if (ret < 0) + TC_PRT("returns %d\n", ret); + break; + } + case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT_SCROLL_DOWN: { + bt_hid_mouse_data_s send_data; + send_data.buttons = BT_HID_MOUSE_BUTTON_NONE; + send_data.padding = 0xff; + send_data.axis_x = 0; + send_data.axis_y = 0; + TC_PRT("Scroll Down"); + ret = bt_hid_device_send_mouse_event(remote_addr, &send_data); + if (ret < 0) + TC_PRT("returns %d\n", ret); + break; + } case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_KEY_EVENT: { bt_hid_key_data_s send_data; /* Will send character 'a' */ diff --git a/test/bt_unit_test.h b/test/bt_unit_test.h index cd392eb..8c11dd4 100644 --- a/test/bt_unit_test.h +++ b/test/bt_unit_test.h @@ -70,9 +70,11 @@ typedef enum { BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY, BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING, BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE, + BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_PROFILE_CONNECTED_DEVICES, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO, BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY, + BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY, BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB, BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA, @@ -122,6 +124,7 @@ typedef enum { BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_DEVICE_ADDRESS, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_SERVICE_UUID, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_SERVICE_SOLICITATION_UUID, +BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_MANUFACTURER_DATA, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_IBEACON_DATA, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNREGISTER_ALL_SCAN_FILTERS, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB, @@ -148,6 +151,8 @@ typedef enum { BT_UNIT_TEST_FUNCTION_DEVICE_DISABLE_RSSI_MONITOR, BT_UNIT_TEST_FUNCTION_DEVICE_GET_RSSI_STRENGTH, BT_UNIT_TEST_FUNCTION_DEVICE_GET_CONNECTION_STATE, + BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION_MODE, + BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION, BT_UNIT_TEST_FUNCTION_DEVICE_REQUEST_ATT_MTU, BT_UNIT_TEST_FUNCTION_DEVICE_SET_REQUEST_ATT_MTU_CHANGED_CB, BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_REQUEST_ATT_MTU_CHANGED_CB, @@ -224,6 +229,7 @@ typedef enum { BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT, BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB, BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_GATT_SET_WRITE_TYPE, BT_UNIT_TEST_FUNCTION_GATT_CLIENT_CREATE, BT_UNIT_TEST_FUNCTION_GATT_CLIENT_DESTROY, BT_UNIT_TEST_FUNCTION_GATT_CLIENT_GET_REMOTE_ADDRESS, @@ -330,6 +336,8 @@ typedef enum { BT_UNIT_TEST_FUNCTION_HID_DEVICE_DISCONNECT, BT_UNIT_TEST_FUCNTION_HID_DEVICE_DEACTIVATE, BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT, + BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT_SCROLL, + BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT_SCROLL_DOWN, BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_KEY_EVENT, BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_RC_KEY_EVENT, BT_UNIT_TEST_FUNCTION_HID_DEVICE_SET_DATA_RECEIVED_CB, @@ -399,6 +407,7 @@ typedef enum { BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_ANSWER, BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_INIT, BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_TERM, + BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_WITH_PARAM, BT_UNIT_TEST_FUNCTION_HF_GET_CALL_STATUS_INFO_LIST, BT_UNIT_TEST_FUNCTION_HF_SET_CALL_EVENT_CB, BT_UNIT_TEST_FUNCTION_HF_UNSET_CALL_EVENT_CB,