{"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"},
{"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"},
{"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"},
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:
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;
}
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;
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) {
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) {
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;
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;
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);
}
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;
}
, 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"
__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;
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;
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) {
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;
}
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]);
TC_PRT("+");
char val = 0x01;
int ret = 0;
+ static char hidmode = 0x01;
if (data == NULL) {
TC_PRT("No received data");
return;
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;
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,
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);
}
}
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) {
__bt_get_error_message(ret));
} else {
- TC_PRT("HPS DISconnected");
+ TC_PRT("HPS DISconnected [%s]", remote_address);
}
}
__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)
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;
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;
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));
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;
}
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);
}
#else
test_input_callback((void *)test_id);
#endif
-
param_index = 0;
return 0;
}
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));
}
#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;
}
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;
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;
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);
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];
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;
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);
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;
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);
__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;
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;
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");
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);
}
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: {
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' */
projects / platform / core / api / bluetooth.git / commitdiff