BT_EVENT_HID_DEVICE_DATA_RECEIVED, /**< HID Device Data received callback */
BT_EVENT_DEVICE_CONNECTION_STATUS, /**< Device connection status callback */
BT_EVENT_GATT_CONNECTION_STATUS, /** < GATT connection status callback */
+ BT_EVENT_GATT_ATT_MTU_CHANGE_STATUS, /** < GATT Attribute MTU change status callback */
BT_EVENT_GATT_CLIENT_SERVICE_DISCOVERED, /** GATT services discovered callback */
+ BT_EVENT_GATT_CLIENT_SERVICE_CHANGED, /** GATT services changed callback */
BT_EVENT_GATT_CLIENT_VALUE_CHANGED, /**< GATT characteristic value changed callback */
BT_EVENT_GATT_CLIENT_READ_CHARACTERISTIC, /**< GATT characteristic value read callback */
BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC, /**< GATT characteristic value write callback */
BT_EVENT_LE_DATA_LENGTH_CHANGED, /** LE data length changed callback */
BT_EVENT_ADVERTISING_STATE_CHANGED, /**< Advertising state changed callback */
BT_EVENT_MANUFACTURER_DATA_CHANGED, /**< Manufacturer data changed callback */
+ BT_EVENT_PASSKEY_NOTIFICATION_EVENT, /**< Display passkey callback */
BT_EVENT_CONNECTABLE_CHANGED_EVENT, /**< Adapter connectable changed callback */
BT_EVENT_RSSI_ENABLED_EVENT, /**< RSSI Enabled callback */
BT_EVENT_RSSI_ALERT_EVENT, /**< RSSI Alert callback */
BT_EVENT_GET_RSSI_EVENT, /**< Get RSSI Strength callback */
+ BT_EVENT_LE_READ_MAXIMUM_DATA_LENGTH, /**< Read maximun LE data length callback */
+ BT_EVENT_SUPPORTED_TRUSTED_PROFILE_EVENT, /**< Trusted Profile callback */
#ifdef TIZEN_WEARABLE
BT_EVENT_PBAP_CONNECTION_STATUS, /**< PBAP connection status callback */
BT_EVENT_PBAP_PHONEBOOK_SIZE, /**< PBAP Phonebook Size status callback */
BT_EVENT_HF_VENDOR_DEP_CMD_EVENT, /**< Audio - HF Vendor Command callback */
BT_EVENT_HF_MULTI_CALL_HANDLING_EVENT, /**< Audio - HF 3-way call event callback */
BT_EVENT_HF_CALL_STATUS_UPDATED_EVENT, /**< Audio - HF call status updated callback */
+ BT_EVENT_HF_REMOTE_CALL_EVENT, /**< Audio - HF : call state event callback */
+ BT_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED, /**< Audio - HF : device state changed callback */
#endif
BT_EVENT_MAX
} bt_event_e;
BT_ADAPTER_LE_ADVERTISING_DATA_MANUFACTURER_SPECIFIC_DATA = 0xff, /**< Manufacturer data */
} bt_adapter_le_advertising_data_type_e;
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Called when trying to be displayed the passkey.
+ * @since_tizen 3.0
+ *
+ * @param[in] remote_address The address of remote device
+ * @param[in] passkey The passkey to be paired with remote device
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre This function will be invoked when trying to be displayed the passkey
+ * if callback is registered using bt_adapter_set_passkey_notification().
+ * @see bt_adapter_set_passkey_notification()
+ * @see bt_adapter_unset_passkey_notification()
+ */
+typedef void (*bt_adapter_passkey_notification_cb)(const char *remote_address, const char *passkey, void *user_data);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Registers a callback function to be invoked
+ * when trying to be displayed the passkey.
+ * @since_tizen 3.0
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback 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_PERMISSION_DENIED Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post bt_adapter_passkey_notification_cb() will be invoked.
+ *
+ * @see bt_initialize()
+ */
+int bt_adapter_set_passkey_notification(bt_adapter_passkey_notification_cb callback, void *user_data);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Unregisters the callback function.
+ * @since_tizen 3.0
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED Not initialized
+ * @retval #BT_ERROR_PERMISSION_DENIED Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_initialize()
+ * @see bt_adapter_set_passkey_notification()
+ */
+int bt_adapter_unset_passkey_notification(void);
+
+typedef enum {
+ BT_GATT_CLIENT_SERVICE_ADDED,
+ BT_GATT_CLIENT_SERVICE_REMOVED,
+} bt_gatt_client_service_change_type_e;
+
+typedef void (*bt_gatt_client_service_changed_cb) (bt_gatt_client_h client,
+ bt_gatt_client_service_change_type_e change_type,
+ const char* service_uuid, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Enumerations of the Bluetooth device's LE connection mode.
+ * @since_tizen 3.0
+ */
+typedef enum
+{
+ BT_DEVICE_LE_CONNECTION_MODE_BALANCED, /**< Balanced mode of power consumption and connection latency */
+ BT_DEVICE_LE_CONNECTION_MODE_LOW_LATENCY, /**< Low connection latency but high power consumption */
+ BT_DEVICE_LE_CONNECTION_MODE_LOW_ENERGY, /**< Low power consumption but high connection latency */
+} bt_device_le_connection_mode_e;
+
/**
* @internal
*/
GSList *services;
char *remote_address;
bool services_discovered;
+ bool connected;
+
+ bt_gatt_client_service_changed_cb service_changed_cb;
+ void *service_changed_user_data;
} bt_gatt_client_s;
typedef struct {
GSList *included_services;
GSList *characteristics;
+
+ char **include_handles;
+ char **char_handles;
} bt_gatt_service_s;
typedef struct {
GSList *descriptors;
+ char **desc_handles;
+
bt_gatt_client_characteristic_value_changed_cb value_changed_cb;
void *value_changed_user_data;
bt_gatt_client_request_completed_cb cb;
} bt_gatt_client_cb_data_s;
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Attribute protocol MTU change information structure.
+ * @since_tizen 3.0
+ *
+ * @see bt_device_att_mtu_changed_cb()
+ */
+typedef struct {
+ char *remote_address; /**< The address of remote device */
+ unsigned int mtu; /** < MTU value */
+ unsigned int status; /** < request status*/
+} bt_device_att_mtu_info_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Called when the connection state is changed.
+ * @since_tizen 2.3.1
+ *
+ * @param[in] connected The connection status: (@c true = connected, @c false = disconnected)
+ * @param[in] conn_info The connection information
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_device_set_connection_state_changed_cb()
+ * @see bt_device_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_device_att_mtu_changed_cb)(int result, bt_device_att_mtu_info_s *mtu_info, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Called when RSSI monitoring is enabled.
+ * @since_tizen 3.0
+ *
+ * @param[in] remote_address Remote Device address
+ * @param[in] link_type Link type for the connection (@c 0 = BR/EDR link, @c 1 = LE link).
+ * @param[in] rssi_enabled RSSI monitoring status (@c 1 = enabled, @c 0 = disabled)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_device_enable_rssi_monitor()
+ * @see bt_device_disable_rssi_monitor()
+ */
+typedef void (*bt_rssi_monitor_enabled_cb)(const char *remote_address,
+ bt_device_connection_link_type_e link_type,
+ int rssi_enabled, void *user_data);
+
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Called when RSSI Alert is received.
+ * @since_tizen 3.0
+ *
+ * @param[in] remote_address Remote Device address
+ * @param[in] link_type Link type for the connection (@c 0 = BR/EDR link, @c 1 = LE link).
+ * @param[in] rssi_alert_type RSSI Alert type (@c 1 = High Alert (In-Range Alert), @c 2 = Low Alert)
+ * @param[in] rssi_alert_dbm RSSI Alert signal strength value
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_device_enable_rssi_monitor()
+ * @see bt_device_disable_rssi_monitor()
+ */
+typedef void (*bt_rssi_alert_cb)(char *bt_address,
+ bt_device_connection_link_type_e link_type,
+ int rssi_alert_type, int rssi_alert_dbm, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Called when Raw RSSI signal strength is received.
+ * @since_tizen 3.0
+ *
+ * @param[in] remote_address Remote Device address
+ * @param[in] link_type Link type for the connection (@c 0 = BR/EDR link, @c 1 = LE link).
+ * @param[in] rssi_dbm Raw RSSI signal strength value
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_device_get_rssi_strength()
+ */
+typedef void (*bt_rssi_strength_cb)(char *bt_address,
+ bt_device_connection_link_type_e link_type,
+ int rssi_dbm, void *user_data);
+
+
typedef void (*_bt_gatt_client_value_changed_cb)(char *char_path,
unsigned char *value, int value_length, void *user_data);
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Enumaration for the address type field in manufactrer specific data
+ * @since_tizen 3.0
+ */
+typedef enum {
+ ADDRESS_NONE_TYPE = 0x00,
+ WI_FI_P2P_ADDRESS = 0x01,
+ BLUETOOTH_ADDRESS = 0x02,
+ INDICATION_ADDRESS = 0x04,
+ IPV4_ADDRESS = 0x08,
+ IPV6_ADDRESS = 0x10,
+ UNKNOWN_ADDRESS = 0xff
+} connectivity_address_t;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Enumaration for the proximity locality type field in manufactrer specific data
+ * @since_tizen 3.0
+ */
+typedef enum {
+ NONE_TYPE = 0x00,
+ PROXIMITY = 0x01,
+ CO_PRESENCE = 0x02,
+ UNKNOWN_TYPE= 0xff
+} bt_proximity_locality_t;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Structure of samsung specific manufacturer data
+ * @since_tizen 3.0
+ */
+typedef struct {
+ unsigned char version;
+ unsigned char service_id;
+ unsigned char discovery_version;
+ unsigned char associated_service_id;
+ bt_proximity_locality_t proximity_locality_type;
+ unsigned char proximity_locality_info;
+ unsigned char device_type;
+ unsigned char device_icon;
+ unsigned char auth_info[5];
+ connectivity_address_t addr_type;
+ unsigned char addr1[6];
+ unsigned char addr2[6];
+ unsigned char channel_info;
+ unsigned char associated_service_data_len;
+ unsigned char *associated_service_data_val;
+ char *name;
+} bt_manufacturer_data;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Called when trying to be displayed the passkey.
+ * @since_tizen 3.0
+ *
+ * @param[in] remote_address The address of remote device
+ * @param[in] passkey The passkey to be paired with remote device
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre This function will be invoked when trying to be displayed the passkey
+ * if callback is registered using bt_adapter_set_passkey_notification().
+ * @see bt_adapter_set_passkey_notification()
+ * @see bt_adapter_unset_passkey_notification()
+ */
+typedef void (*bt_adapter_passkey_notification_cb)(const char *remote_address, const char *passkey, void *user_data);
+
+
#define BT_CHECK_INPUT_PARAMETER(arg) \
if (arg == NULL) { \
LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, BT_ERROR_INVALID_PARAMETER); \
*/
char *_bt_convert_error_to_string(int error);
+/**
+ * @internal
+ * @brief Convert uuid to uuid128
+ */
+char* _bt_convert_uuid_to_uuid128(const char *uuid);
+
/**
* @internal
* @brief Convert the visibility mode
void _bt_audio_event_proxy(int event, bt_audio_event_param_t *param, void *user_data);
#ifdef TIZEN_WEARABLE
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
+ * @brief Enumerations for the device state event from Audio-Gateway device
+ * @since_tizen 3.0
+ */
+typedef enum {
+ BT_HF_REMOTE_DEVICE_STATE_BATTERY_LEVEL = 0x00, /**< Battery charge level of AG (ranges from 0 to 5) */
+ BT_HF_REMOTE_DEVICE_STATE_SIGNAL_STRENGTH, /**< Signal strength level of AG (ranges from 0 to 5) */
+ BT_HF_REMOTE_DEVICE_STATE_NETWORK_SERVICE, /**< Network service availability (0:no service , 1:available) */
+ BT_HF_REMOTE_DEVICE_STATE_VOICE_RECOGNITON, /**< Voice Recognition State (0:disabled , 1:enabled) */
+} bt_hf_remote_device_state_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
+ * @brief Called when a device status changed event happend from Audio-Gateway device
+ * @since_tizen 3.0
+ *
+ * @param[in] event The device state chagned event from remote Audio-Gateway device
+ * @param[in] value The new values to be changed.
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @see bt_hf_set_remote_device_state_changed_cb()
+ * @see bt_hf_unset_remote_device_state_changed_cb()
+ */
+typedef void (*bt_hf_remote_device_state_changed_cb) (bt_hf_remote_device_state_e state, int value, void *user_data);
+
/**
* @internal
* @brief Since the HF call back and event proxy call backs have different prototype it is wrapper function.
bool _bt_gatt_is_legacy_client_mode(void);
#endif
-const GSList *_bt_gatt_get_client_list(void);
-const GSList *_bt_gatt_get_server_list(void);
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ * @brief Gets the specification name from the UUID
+ * @since_tizen 3.0
+ *
+ * @remarks @a name must be released with free() by you.
+ *
+ * @param[in] uuid The UUID
+ * @param[out] name The specification name which defined from www.bluetooth.org
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE Successful
+ * @retval #BT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #BT_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @see bt_gatt_get_uuid()
+ */
+int bt_get_uuid_name(const char *uuid, char **name);
+
+bt_gatt_client_h _bt_gatt_get_client(const char *remote_addr);
+
+const GSList* _bt_gatt_get_server_list(void);
+
+bt_gatt_h _bt_gatt_client_add_service(bt_gatt_client_h client, const char *path);
+
+int _bt_gatt_client_update_services(bt_gatt_client_h client);
+
+int _bt_gatt_client_update_include_services(bt_gatt_h service);
+
+int _bt_gatt_client_update_characteristics(bt_gatt_h service);
-int _bt_gatt_client_update_all(bt_gatt_client_h client);
+int _bt_gatt_client_update_descriptors(bt_gatt_h characteristic);
/**
* @ingroup CAPI_NETWORK_BLUETOOTH_LE_MODULE
typedef void (*bt_adapter_manufacturer_data_changed_cb) (char *data,
int len, void *user_data);
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Called repeatedly when you get the devices connected with specific profile.
+ * @since_tizen 3.0
+ *
+ * @param[in] remote_address The address of remote device
+ * @param[in] user_data The user data passed from the callback registration function
+ * @return @c true to continue with the next iteration of the loop,
+ * \n @c false to break out of the loop.
+ * @pre bt_adapter_foreach_profile_connected_devices() will invoke this function.
+ * @see bt_adapter_foreach_profile_connected_devices()
+ */
+typedef bool (*bt_adapter_profile_connected_devices_cb)(const char *remote_address, void *user_data);
+
/**
* @ingroup CAPI_NETWORK_BLUETOOTH_DPM_MODULE
* @brief DPM BT allowance state
*/
typedef void (*bt_hid_device_data_received_cb)(const bt_hid_device_received_data_s *data, void *user_data);
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Trusted Profile enumeration.
+ * @since_tizen 3.0
+ *
+ * @see bt_device_set_profile_trusted()
+ * @see bt_device_get_profile_trusted()
+ */
+typedef enum {
+ BT_TRUSTED_PROFILE_PBAP = 1,
+ BT_TRUSTED_PROFILE_MAP,
+ BT_TRUSTED_PROFILE_SAP,
+ BT_TRUSTED_PROFILE_ALL = 0xFFFFFFFF,
+} bt_trusted_profile_t;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Called when Trusted Profiles is changed.
+ * @since_tizen 3.0
+ *
+ * @param[in] result The result of supported profile callback
+ * @param[in] remote_address Address of remote device
+ * @param[in] trusted_profiles Trusted profile FLAG
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_device_set_trusted_profile_cb()
+ * @see bt_device_unset_trusted_profile_cb()
+ */
+typedef void (*bt_device_trusted_profiles_cb)
+ (int result, char *remote_address, int trusted_profile, bool supported, bool trusted,void *user_data);
+
+
/**
* @internal
* @ingroup
typedef void (*bt_adapter_manufacturer_data_changed_cb) (char *data,
int len, void *user_data);
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Called repeatedly when you get the devices connected with specific profile.
+ * @since_tizen 3.0
+ *
+ * @param[in] remote_address The address of remote device
+ * @param[in] user_data The user data passed from the callback registration function
+ * @return @c true to continue with the next iteration of the loop,
+ * \n @c false to break out of the loop.
+ * @pre bt_adapter_foreach_profile_connected_devices() will invoke this function.
+ * @see bt_adapter_foreach_profile_connected_devices()
+ */
+typedef bool (*bt_adapter_profile_connected_devices_cb)(const char *remote_address, void *user_data);
+
/**
* @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
* @brief Called when the SCO(Synchronous Connection Oriented link) state is changed.
char **uuids;
} bt_dpm_uuids_list_s;
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Trusted Profile enumeration.
+ * @since_tizen 3.0
+ *
+ * @see bt_device_set_profile_trusted()
+ * @see bt_device_get_profile_trusted()
+ */
+typedef enum {
+ BT_TRUSTED_PROFILE_PBAP = 1,
+ BT_TRUSTED_PROFILE_MAP,
+ BT_TRUSTED_PROFILE_SAP,
+ BT_TRUSTED_PROFILE_ALL = 0xFFFFFFFF,
+} bt_trusted_profile_t;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Called when Trusted Profiles is changed.
+ * @since_tizen 3.0
+ *
+ * @param[in] result The result of supported profile callback
+ * @param[in] remote_address Address of remote device
+ * @param[in] trusted_profiles Trusted profile FLAG
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_device_set_trusted_profile_cb()
+ * @see bt_device_unset_trusted_profile_cb()
+ */
+typedef void (*bt_device_trusted_profiles_cb)
+ (int result, char *remote_address, int trusted_profile, bool supported, bool trusted,void *user_data);
+
/**
* @internal
* @brief IPSP Init state changed callback
goto ERROR;
}
info_size = info_end - info_start - 1;
+ if (info_size < 0) {
+ BT_ERR("info_size is invalid(%d)", info_size);
+ ret = BT_ERROR_OPERATION_FAILED;
+ goto ERROR;
+ }
local_firmware = (char *)malloc(sizeof(char) *(info_size + 1));
if (local_firmware == NULL) {
return ret;
}
+int bt_adapter_foreach_profile_connected_devices(const char *profile_uuid,
+ bt_adapter_profile_connected_devices_cb callback, void *user_data)
+{
+ char *uuid128;
+ GPtrArray *addr_list = NULL;
+ bluetooth_device_address_t *remote_addr = NULL;
+ char *remote_address = NULL;
+ int ret = BT_ERROR_NONE;
+ int i = 0;
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(profile_uuid);
+ BT_CHECK_INPUT_PARAMETER(callback);
+
+ uuid128 = _bt_convert_uuid_to_uuid128(profile_uuid);
+ if (uuid128 == NULL) {
+ BT_ERR("Wrong type of uuid : %s", profile_uuid);
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+
+ addr_list = g_ptr_array_new();
+ if (addr_list == NULL) {
+ BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY);
+ return BT_ERROR_OUT_OF_MEMORY;
+ }
+
+ ret = _bt_get_error_code(
+ bluetooth_get_profile_connected_device_list(uuid128, &addr_list));
+ g_free(uuid128);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x) : Failed to get profile connected device list",
+ _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+
+ for (i = 0; i < addr_list->len; i++) {
+ remote_addr = g_ptr_array_index(addr_list, i);
+ if (remote_addr != NULL) {
+ ret = _bt_convert_address_to_string(&remote_address, remote_addr);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+
+ if (!callback(remote_address, user_data)) {
+ g_free(remote_address);
+ break;
+ }
+ g_free(remote_address);
+ } else {
+ BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED);
+ ret = BT_ERROR_OPERATION_FAILED;
+ break;
+ }
+ }
+
+ g_ptr_array_foreach(addr_list, (GFunc)g_free, NULL);
+ g_ptr_array_free(addr_list, TRUE);
+
+ return ret;
+}
+
int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback,
void *user_data)
{
ret = _bt_get_error_code(bluetooth_oob_read_local_data(&oob_data));
if (BT_ERROR_NONE == ret) {
- *hash = g_memdup(oob_data.hash, BLUETOOTH_OOB_DATA_LENGTH);
+ *hash = g_memdup(oob_data.hash, oob_data.hash_len);
*randomizer = g_memdup(oob_data.randomizer,
- BLUETOOTH_OOB_DATA_LENGTH);
- *hash_len = BLUETOOTH_OOB_DATA_LENGTH;
- *randomizer_len = BLUETOOTH_OOB_DATA_LENGTH;
+ oob_data.randomizer_len);
+ *hash_len = oob_data.hash_len;
+ *randomizer_len = oob_data.randomizer_len;
} else {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
ret); /* LCOV_EXCL_LINE */
int ret = BT_ERROR_NONE;
bluetooth_device_address_t addr_hex = { {0,} };
bt_oob_data_t oob_data = { {0},};
+ int len;
BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
BT_CHECK_INIT_STATUS();
_bt_convert_address_to_hex(&addr_hex, remote_address);
- if (hash != NULL && randomizer != NULL) {
- memcpy(oob_data.hash, hash, hash_len);
- memcpy(oob_data.randomizer, randomizer, randomizer_len);
- oob_data.hash_len = hash_len;
- oob_data.randomizer_len = randomizer_len;
+ if (hash && randomizer) {
+ len = hash_len < BLUETOOTH_OOB_DATA_LENGTH ?
+ hash_len : BLUETOOTH_OOB_DATA_LENGTH;
+ memcpy(oob_data.hash, hash, len);
+ oob_data.hash_len = len;
+
+ len = randomizer_len < BLUETOOTH_OOB_DATA_LENGTH ?
+ randomizer_len : BLUETOOTH_OOB_DATA_LENGTH;
+ memcpy(oob_data.randomizer, randomizer, len);
+ oob_data.randomizer_len = len;
+ } else {
+ return BT_ERROR_INVALID_PARAMETER;
}
ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex,
return ret;
}
+int bt_adapter_get_local_oob_ext_data(unsigned char **hash192, unsigned char **randomizer192,
+ int *hash192_len, int *randomizer192_len,
+ unsigned char **hash256, unsigned char **randomizer256,
+ int *hash256_len, int *randomizer256_len)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(hash192);
+ BT_CHECK_INPUT_PARAMETER(randomizer192);
+ BT_CHECK_INPUT_PARAMETER(hash192_len);
+ BT_CHECK_INPUT_PARAMETER(randomizer192_len);
+ BT_CHECK_INPUT_PARAMETER(hash256);
+ BT_CHECK_INPUT_PARAMETER(randomizer256);
+ BT_CHECK_INPUT_PARAMETER(hash256_len);
+ BT_CHECK_INPUT_PARAMETER(randomizer256_len);
+
+ bt_oob_data_t oob_data;
+
+ ret = _bt_get_error_code(bluetooth_oob_read_local_data(&oob_data));
+ if (BT_ERROR_NONE == ret) {
+ *hash192 = *randomizer192 = NULL;
+ *hash192_len = *randomizer192_len = 0;
+
+ *hash256 = *randomizer256 = NULL;
+ *hash256_len = *randomizer256_len = 0;
+
+ if (oob_data.hash_len && oob_data.randomizer_len) {
+ *hash192 = g_memdup(oob_data.hash, oob_data.hash_len);
+ *randomizer192 = g_memdup(oob_data.randomizer,
+ oob_data.randomizer_len);
+
+ *hash192_len = oob_data.hash_len;
+ *randomizer192_len = oob_data.randomizer_len;
+ }
+
+ if (oob_data.hash256_len && oob_data.randomizer256_len) {
+ *hash256 = g_memdup(oob_data.hash256, oob_data.hash256_len);
+ *randomizer256 = g_memdup(oob_data.randomizer256,
+ oob_data.randomizer256_len);
+
+ *hash256_len = oob_data.hash256_len;
+ *randomizer256_len = oob_data.randomizer256_len;
+ }
+ } else {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_adapter_set_remote_oob_ext_data(const char *remote_address,
+ const unsigned char *hash192, const unsigned char *randomizer192,
+ int hash192_len, int randomizer192_len,
+ const unsigned char *hash256, const unsigned char *randomizer256,
+ int hash256_len, int randomizer256_len)
+{
+ int ret = BT_ERROR_NONE;
+ bluetooth_device_address_t addr_hex = { {0,} };
+ bt_oob_data_t oob_data = { {0},};
+ int len;
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+
+ if ((!hash192 || !randomizer192) && (!hash256 || !randomizer256))
+ return BT_ERROR_INVALID_PARAMETER;
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ if (hash192 && randomizer192) {
+ len = hash192_len < BLUETOOTH_OOB_DATA_LENGTH ?
+ hash192_len : BLUETOOTH_OOB_DATA_LENGTH;
+ memcpy(oob_data.hash, hash192, len);
+ oob_data.hash_len = len;
+
+ len = randomizer192_len < BLUETOOTH_OOB_DATA_LENGTH ?
+ randomizer192_len : BLUETOOTH_OOB_DATA_LENGTH;
+ memcpy(oob_data.randomizer, randomizer192, len);
+ oob_data.randomizer_len = len;
+ }
+
+ if (hash256 && randomizer256) {
+ len = hash256_len < BLUETOOTH_OOB_DATA_LENGTH ?
+ hash256_len : BLUETOOTH_OOB_DATA_LENGTH;
+ memcpy(oob_data.hash256, hash256, len);
+ oob_data.hash256_len = len;
+
+ len = randomizer256_len < BLUETOOTH_OOB_DATA_LENGTH ?
+ randomizer256_len : BLUETOOTH_OOB_DATA_LENGTH;
+ memcpy(oob_data.randomizer256, randomizer256, len);
+ oob_data.randomizer256_len = len;
+ }
+
+ ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex, &oob_data));
+ if (BT_ERROR_NONE != ret) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
int bt_adapter_remove_remote_oob_data(const char *remote_address)
{
int ret = BT_ERROR_NONE;
return ret;
}
+int bt_adapter_parse_manufacturer_data(bt_manufacturer_data *data, char *manufacturer_data, int manufacturer_data_len)
+{
+
+ int cursor, name_len;
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(data);
+ BT_CHECK_INPUT_PARAMETER(manufacturer_data);
+
+ if (manufacturer_data_len < 30) {
+ BT_DBG("minimum Size of the smasung specific manufacturer data is greater than 30 ");
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+ if (manufacturer_data[0] != 0x00 || manufacturer_data[1] != 0x75) {
+ BT_DBG("This is not a samsung specific manufaturer data");
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+
+ cursor = 2;
+
+/* control and version */
+ data->version = manufacturer_data[cursor++];
+
+/* service ID */
+ data->service_id = manufacturer_data[cursor++];
+
+/* Samsung discovery version */
+ data->discovery_version = manufacturer_data[cursor++];
+
+/* associated service ID */
+ data->associated_service_id = manufacturer_data[cursor++];
+
+/* Proxamity and locality */
+ /* type */
+ data->proximity_locality_type = manufacturer_data[cursor++];
+
+ /* info */
+ data->proximity_locality_info = manufacturer_data[cursor++];
+
+/* Device */
+ /* type */
+ data->device_type = manufacturer_data[cursor++];
+
+ /* icon */
+ data->device_icon = manufacturer_data[cursor++];
+
+ /* Authentication info */
+ memcpy(data->auth_info, &(manufacturer_data[cursor]), 5);
+ cursor = cursor + 5;
+
+/* Connectivity */
+ /* address type */
+ data->addr_type = manufacturer_data[cursor++];
+
+ /* addr1 */
+ memcpy(data->addr1, &(manufacturer_data[cursor]), 6);
+ cursor = cursor + 6;
+
+ /* addr2 */
+ memcpy(data->addr2, &(manufacturer_data[cursor]), 6);
+ cursor = cursor + 6;
+
+ /* channel info */
+ data->channel_info = manufacturer_data[cursor++];
+
+
+/* Associated service data */
+ data->associated_service_data_len = manufacturer_data[cursor++];
+ if (data->associated_service_data_len) {
+ data->associated_service_data_val = g_malloc0(data->associated_service_data_len);
+ memcpy(data->associated_service_data_val, &(manufacturer_data[cursor]),
+ data->associated_service_data_len);
+
+ cursor = cursor + data->associated_service_data_len;
+ }
+
+/* name : include the null termination */
+ name_len = manufacturer_data_len - cursor;
+ if (name_len > 0) {
+ data->name= g_malloc0(name_len + 1);
+ memcpy(data->name, &(manufacturer_data[cursor]), name_len);
+ data->name[name_len] = '\0';
+ }
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_free_manufacturer_data(bt_manufacturer_data *data)
+{
+ BT_CHECK_INPUT_PARAMETER(data);
+ g_free(data->associated_service_data_val);
+ g_free(data->name);
+ return BT_ERROR_NONE;
+}
+
int bt_adapter_set_manufacturer_data_changed_cb(
bt_adapter_manufacturer_data_changed_cb callback,
void *user_data)
return BT_ERROR_NONE;
}
+int bt_adapter_set_passkey_notification(
+ bt_adapter_passkey_notification_cb callback, void *user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+
+ ret = _bt_get_error_code(bluetooth_set_passkey_notification(TRUE));
+ if (ret == BT_ERROR_NONE) {
+ _bt_set_cb(BT_EVENT_PASSKEY_NOTIFICATION_EVENT,
+ callback, user_data);
+ } else {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_adapter_unset_passkey_notification(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+
+ ret = _bt_get_error_code(bluetooth_set_passkey_notification(FALSE));
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ }
+
+ _bt_unset_cb(BT_EVENT_PASSKEY_NOTIFICATION_EVENT);
+
+ return BT_ERROR_NONE;
+}
+
int bt_adapter_le_add_white_list(const char *address,
bt_device_address_type_e address_type)
{
}
/* LCOV_EXCL_STOP */
+int bt_adapter_le_set_customized_scan_mode(float scan_interval, float scan_window)
+{
+ int ret = BT_ERROR_NONE;
+ bluetooth_le_scan_params_t scan_params;
+
+ BT_CHECK_INIT_STATUS();
+
+ scan_params.type = BT_ADAPTER_LE_ACTIVE_SCAN;
+ scan_params.interval = scan_interval;
+ scan_params.window = scan_window;
+
+ ret = _bt_get_error_code(bluetooth_set_scan_parameters(&scan_params));
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ }
+ return ret;
+}
+
int bt_adapter_le_create_advertiser(bt_advertiser_h *advertiser)
{
bt_advertiser_s *__adv = NULL;
if (i + len > in_len) {
BT_ERR("Invalid advertising data"); /* LCOV_EXCL_LINE */
return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
- } else if (len == 0 &&
- in_type != BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME &&
- in_type != BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL) {
- BT_INFO("AD Type 0x%02x data is not set",
- in_type); /* LCOV_EXCL_LINE */
- return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
+ } else if (len == 0) {
+ BT_INFO("AD Type 0x%02x data is not set", in_type);
+ return BT_ERROR_OPERATION_FAILED;
}
p = (char *)malloc(sizeof(char) *(in_len - len));
char *adv_data = NULL;
int uuid_bit;
char *uuid_ptr;
- int byte_len;
+ int byte_len = 0;
char *converted_uuid = NULL;
BT_CHECK_LE_SUPPORT();
return error_code;
}
+int bt_adapter_le_set_static_random_address(bool enable)
+{
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_LE_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+
+ error_code = _bt_get_error_code(bluetooth_set_le_static_random_address(enable));
+
+ if (error_code != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ }
+ return error_code;
+}
+
static void __bt_adapter_le_convert_scan_filter(
bluetooth_le_scan_filter_t *dest,
bt_le_scan_filter_s *src)
{
int bit;
char *data;
+ char *converted_uuid = NULL;
memset(dest, 0x00, sizeof(bluetooth_le_scan_filter_t));
dest->service_uuid.data_len = 2;
else
dest->service_uuid.data_len = 16;
- memcpy(dest->service_uuid.data.data, data,
+
+ if (__bt_convert_byte_ordering(data, dest->service_uuid.data_len,
+ &converted_uuid) == BT_ERROR_NONE) {
+ memcpy(dest->service_uuid.data.data, converted_uuid,
dest->service_uuid.data_len);
+ g_free(converted_uuid);
+ converted_uuid = NULL;
+ }
g_free(data);
+ data = NULL;
dest->service_uuid_mask.data_len = dest->service_uuid.data_len;
if (src->service_uuid_mask) {
- __bt_convert_string_to_uuid(
- src->service_uuid_mask, &data, &bit);
- memcpy(dest->service_uuid_mask.data.data, data,
- dest->service_uuid_mask.data_len);
+ __bt_convert_string_to_uuid(src->service_uuid_mask, &data, &bit);
+
+ if (__bt_convert_byte_ordering(data, dest->service_uuid_mask.data_len,
+ &converted_uuid) == BT_ERROR_NONE) {
+ memcpy(dest->service_uuid_mask.data.data, converted_uuid,
+ dest->service_uuid_mask.data_len);
+ g_free(converted_uuid);
+ converted_uuid = NULL;
+ }
g_free(data);
+ data = NULL;
} else {
memset(dest->service_uuid_mask.data.data, 0xFF,
dest->service_uuid_mask.data_len);
dest->service_solicitation_uuid.data_len = 2;
else
dest->service_solicitation_uuid.data_len = 16;
- memcpy(dest->service_solicitation_uuid.data.data, data,
- dest->service_solicitation_uuid.data_len);
+
+ if (__bt_convert_byte_ordering(data, dest->service_solicitation_uuid.data_len,
+ &converted_uuid) == BT_ERROR_NONE) {
+ memcpy(dest->service_solicitation_uuid.data.data,
+ converted_uuid, dest->service_solicitation_uuid.data_len);
+ g_free(converted_uuid);
+ converted_uuid = NULL;
+ }
g_free(data);
+ data = NULL;
dest->service_solicitation_uuid_mask.data_len = dest->service_solicitation_uuid.data_len;
if (src->service_solicitation_uuid_mask) {
- __bt_convert_string_to_uuid(
- src->service_solicitation_uuid_mask,
- &data, &bit);
- memcpy(dest->service_solicitation_uuid_mask.data.data, data, dest->service_solicitation_uuid_mask.data_len);
+ __bt_convert_string_to_uuid(src->service_solicitation_uuid_mask, &data, &bit);
+
+ if (__bt_convert_byte_ordering(data, dest->service_solicitation_uuid_mask.data_len,
+ &converted_uuid) == BT_ERROR_NONE) {
+ memcpy(dest->service_solicitation_uuid_mask.data.data,
+ converted_uuid, dest->service_solicitation_uuid_mask.data_len);
+ g_free(converted_uuid);
+ converted_uuid = NULL;
+ }
g_free(data);
+ data = NULL;
} else {
memset(dest->service_solicitation_uuid_mask.data.data, 0xFF, dest->service_solicitation_uuid_mask.data_len);
}
}
if (src->service_data_uuid) {
- char *service_uuid;
int uuid_len;
- if (__bt_convert_string_to_uuid(src->service_data_uuid,
- &service_uuid, &bit) == BT_ERROR_NONE) {
+ if (__bt_convert_string_to_uuid(src->service_data_uuid, &data, &bit) == BT_ERROR_NONE) {
dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA;
if (bit == 16)
uuid_len = 2;
else
uuid_len = 16;
- memcpy(dest->service_data.data.data, service_uuid, uuid_len);
- g_free(service_uuid);
- memcpy(dest->service_data.data.data + uuid_len,
- src->service_data, src->service_data_len);
- dest->service_data.data_len = uuid_len
- + src->service_data_len;
-
- dest->service_data_mask.data_len = uuid_len
- + src->service_data_len;
- memset(dest->service_data_mask.data.data,
- 0xFF, uuid_len);
+ if (__bt_convert_byte_ordering(data, uuid_len, &converted_uuid)
+ == BT_ERROR_NONE) {
+ memcpy(dest->service_data.data.data, converted_uuid, uuid_len);
+ g_free(converted_uuid);
+ converted_uuid = NULL;
+ }
+ g_free(data);
+ data = NULL;
+
+ memcpy(dest->service_data.data.data + uuid_len, src->service_data, src->service_data_len);
+ dest->service_data.data_len = uuid_len + src->service_data_len;
+
+ dest->service_data_mask.data_len = dest->service_data.data_len;
+ memset(dest->service_data_mask.data.data, 0xFF, uuid_len);
if (src->service_data_mask)
memcpy(dest->service_data_mask.data.data + uuid_len, src->service_data_mask, src->service_data_len);
else
bt_le_scan_filter_s *__filter = NULL;
BT_CHECK_LE_SUPPORT();
+ if (bluetooth_is_scan_filter_supported() == FALSE) {
+ BT_ERR("BT_ERROR_NOT_SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+ return BT_ERROR_NOT_SUPPORTED;
+ }
+
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(scan_filter);
int error_code = BT_ERROR_NONE;
BT_CHECK_LE_SUPPORT();
+ if (bluetooth_is_scan_filter_supported() == FALSE) {
+ BT_ERR("BT_ERROR_NOT_SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+ return BT_ERROR_NOT_SUPPORTED;
+ }
+
BT_CHECK_INIT_STATUS();
if (bluetooth_is_le_scanning() == TRUE) {
BT_ERR("NOW_IN_PROGRESS(0x%08x)",
return BT_ERROR_NONE;
}
+
int bt_adapter_le_read_maximum_data_length(
int *max_tx_octets, int *max_tx_time,
int *max_rx_octets, int *max_rx_time)
return ret;
}
+int bt_adapter_force_hcidump(int timeout)
+{
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_LE_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+
+ error_code = _bt_get_error_code(bluetooth_force_hcidump(timeout));
+
+ if (error_code != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ }
+ return error_code;
+}
+
int bt_adapter_set_authentication_req_cb(bt_adapter_authentication_req_cb callback,
void *user_data)
{
case BT_AG_CALL_EVENT_ALERTING:
error = bluetooth_telephony_call_remote_ringing(call_id);
break;
- case BT_AG_CALL_EVENT_INCOMING:
- BT_CHECK_INPUT_PARAMETER(phone_number);
- error = bluetooth_telephony_indicate_incoming_call(phone_number,
+ case BT_AG_CALL_EVENT_INCOMING: {
+ const char *ph_number;
+ if (phone_number) {
+ ph_number = phone_number;
+ } else {
+ ph_number = "";
+ }
+ error = bluetooth_telephony_indicate_incoming_call(ph_number,
call_id);
break;
+ }
default:
error = BLUETOOTH_TELEPHONY_ERROR_INVALID_PARAM;
}
}
/* LCOV_EXCL_STOP */
+int bt_ag_notify_vendor_cmd(const char *command)
+{
+ int error;
+
+ BT_CHECK_HFP_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_AG_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(command);
+
+ error = bluetooth_telephony_send_vendor_cmd(command);
+ error = _bt_convert_telephony_error_code(error);
+ if (error != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
+ }
+ return error;
+}
+
int bt_ag_notify_voice_recognition_state(bool state)
{
int error;
return BT_ERROR_OUT_OF_MEMORY;
call_status->call_id = call_id;
call_status->call_status = state;
- call_status->phone_number = g_strdup(phone_number);
+ if (phone_number) {
+ call_status->phone_number = g_strdup(phone_number);
+ } else {
+ call_status->phone_number = g_strdup("");
+ }
handle->list = g_list_append(handle->list, (gpointer)call_status);
return BT_ERROR_NONE;
return error;
}
+int bt_hf_is_inband_ringtone_supported(bool *supported)
+{
+#ifdef TIZEN_BT_HFP_HF_ENABLE
+ int error;
+ gboolean is_supported = FALSE;
+
+ BT_CHECK_HF_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(supported);
+
+ error = bluetooth_hf_is_ibr_supported(&is_supported);
+ error = _bt_get_error_code(error);
+ if (error != BT_ERROR_NONE)
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
+
+ if (is_supported)
+ *supported = TRUE;
+ else
+ *supported = FALSE;
+
+ return error;
+#else
+ BT_ERR("NOT_SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+ return BT_ERROR_NOT_SUPPORTED;
+#endif
+}
+
static void __bt_hf_free_call_status_info(void *data)
{
bt_hf_call_status_info_s *call_info = (bt_hf_call_status_info_s *)data;
_bt_unset_cb(BT_EVENT_HF_MULTI_CALL_HANDLING_EVENT);
return BT_ERROR_NONE;
}
-#endif
+
+int bt_hf_set_remote_call_event_cb(
+ bt_hf_remote_call_event_cb callback,
+ void *user_data)
+{
+ BT_CHECK_HF_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_HF_REMOTE_CALL_EVENT, callback, user_data);
+ return BT_ERROR_NONE;
+}
+
+int bt_hf_unset_remote_call_event_cb(void)
+{
+ BT_CHECK_HF_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ if (_bt_check_cb(BT_EVENT_HF_REMOTE_CALL_EVENT) == true)
+ _bt_unset_cb(BT_EVENT_HF_REMOTE_CALL_EVENT);
+ return BT_ERROR_NONE;
+}
+
+int bt_hf_set_remote_device_state_changed_cb(
+ bt_hf_remote_device_state_changed_cb callback,
+ void *user_data)
+{
+ BT_CHECK_HF_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED, callback, user_data);
+ return BT_ERROR_NONE;
+}
+
+int bt_hf_unset_remote_device_state_changed_cb(void)
+{
+ BT_CHECK_HF_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ if (_bt_check_cb(BT_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED) == true)
+ _bt_unset_cb(BT_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED);
+ return BT_ERROR_NONE;
+}
+#endif
\ No newline at end of file
return BT_ERROR_NONE;
}
+int bt_avrcp_target_connect(const char *remote_address)
+{
+ int error;
+ bluetooth_device_address_t addr_hex = { {0,} };
+
+ BT_CHECK_AVRCP_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_AVRCP_TARGET_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ error = bluetooth_media_target_connect(&addr_hex);
+ 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_avrcp_target_disconnect(const char *remote_address)
+{
+ int error;
+ bluetooth_device_address_t addr_hex = { {0,} };
+
+ BT_CHECK_AVRCP_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_AVRCP_TARGET_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ error = bluetooth_media_target_disconnect(&addr_hex);
+ 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_avrcp_target_deinitialize(void)
{
int error;
static void __bt_le_event_proxy(int event, bluetooth_event_param_t *param, void *user_data);
static int __bt_get_cb_index(int event);
static void __bt_convert_lower_to_upper(char *origin);
-static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source);
+static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source, int error);
static void __bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s *sdp_info);
static int __bt_get_bt_device_connection_info_s(bt_device_connection_info_s **dest, bt_connection_info_t *source);
static void __bt_free_bt_device_connection_info_s(bt_device_connection_info_s *conn_info);
int bt_initialize(void)
{
+ int ret;
+
BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
if (is_initialized != true) {
- if (bluetooth_register_callback(&__bt_event_proxy, NULL) != BLUETOOTH_ERROR_NONE) {
+ ret = bluetooth_register_callback(&__bt_event_proxy, NULL);
+ if (ret != BLUETOOTH_ERROR_NONE && ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); /* LCOV_EXCL_LINE */
return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
}
+int bt_get_uuid_name(const char *uuid, char **name)
+{
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INPUT_PARAMETER(uuid);
+ BT_CHECK_INPUT_PARAMETER(name);
+
+ int i;
+ int offset = 0;
+ int uuid_len = 4;
+ static struct {
+ const char *uuid;
+ const char *specification_name;
+ } bt_uuid_name[] = {
+ /* BT Classic Services */
+ {"1101", "Serial Port Service"},
+ {"1102", "LAN Access Using PPP Service"},
+ {"1103", "Dialup Netwworking Service"},
+ {"1104", "IrMCSync Service"},
+ {"1105", "OBEX Object Push Service"},
+ {"1106", "OBEX File Transfer Service"},
+ {"1107", "IrMC Sync Command Service"},
+ {"1108", "Headset Service"},
+ {"1109", "Cordless Telephony Service"},
+ {"110A", "Audio Source Service"},
+ {"110B", "Audio Sink Service"},
+ {"110C", "AV Remote Control Target Service"},
+ {"110D", "Advanced Audio Distribution Profile"},
+ {"110E", "AV Remote Control Service"},
+ {"110F", "Video Conferencing Service"},
+ {"1110", "Intercom Service"},
+ {"1111", "Fax Service"},
+ {"1112", "Headset Audio Gateway Service"},
+ {"1113", "WAP Service"},
+ {"1114", "WAP Client Service"},
+ {"1115", "PANU Service"},
+ {"1116", "NAP Service"},
+ {"1117", "GN Service"},
+ {"1118", "Direct Printing Service"},
+ {"1119", "Reference Printing Service"},
+ {"111A", "Basic Imaging Profile"},
+ {"111B", "Imaging Responder Service"},
+ {"111C", "Imaging Automatic Archive Service"},
+ {"111D", "Imaging Reference Objects Service"},
+ {"111E", "Handsfree Service"},
+ {"111F", "Handsfree Audio Gateway Service"},
+ {"1120", "Direct Printing Reference Objects Service"},
+ {"1121", "Reflected UI Service"},
+ {"1122", "Basic Printing Profile"},
+ {"1123", "Printing Status Service"},
+ {"1124", "Human Interface Device Service"},
+ {"1125", "Hardcopy Cable Replacement Profile"},
+ {"1126", "HCR Print Service"},
+ {"1127", "HCR Scan Service"},
+ {"112D", "SIM Access Service"},
+ {"112E", "Phonebook Access PCE Service"},
+ {"112F", "Phonebook Access PSE Service"},
+ {"1130", "Phonebook Access Profile"},
+ {"1132", "Message Access Server Service"},
+ {"1133", "Message Notification Server Service"},
+ {"1134", "Message Access Profile"},
+ {"1200", "PnP Information Service"},
+ {"1201", "Generic Networking Service"},
+ {"1202", "Generic File Transfer Service"},
+ {"1203", "Generic Audio Service"},
+ {"1204", "Generic Telephony Service"},
+ {"1205", "UPnP Service"},
+ {"1206", "UPnP Ip Service"},
+ {"1400", "Health Device Profile"},
+
+ /* GATT Services */
+ {"1800", "Generic Access"},
+ {"1801", "Generic Attribute"},
+ {"1802", "Immediate Alert"},
+ {"1803", "Link Loss"},
+ {"1804", "Tx Power"},
+ {"1805", "Current Time Service"},
+ {"1806", "Reference Time Update Service"},
+ {"1807", "Next DST Change Service"},
+ {"1808", "Glucose"},
+ {"1809", "Health Thermometer"},
+ {"180A", "Device Information"},
+ {"180D", "Heart Rate"},
+ {"180F", "Battery Service"},
+ {"1810", "Blood Pressure"},
+ {"1811", "Alert Notification Service"},
+ {"1812", "Human Interface Device"},
+
+ /* GATT Declarations */
+ {"2800", "Primary Service Declaration"},
+ {"2801", "Secondary Service Declaration"},
+ {"2802", "Include Declaration"},
+ {"2803", "Characteristic Declaration"},
+
+ /* GATT Descriptors */
+ {"2900", "Characteristic Extended Properties"},
+ {"2901", "Characteristic User Description"},
+ {"2902", "Client Characteristic Configuration"},
+ {"2903", "Server Characteristic Configuration"},
+ {"2904", "Characteristic Format"},
+ {"2905", "Characteristic Aggregate Formate"},
+ {"2906", "Valid Range"},
+ {"2907", "External Report Reference"},
+ {"2908", "Report Reference"},
+
+ /* GATT Characteristics */
+ {"2A00", "Device Name"},
+ {"2A01", "Appearance"},
+ {"2A02", "Peripheral Privacy Flag"},
+ {"2A03", "Reconnection Address"},
+ {"2A04", "Peripheral Preferred Connection Parameters"},
+ {"2A05", "Service Changed"},
+ {"2A06", "Alert Level"},
+ {"2A07", "Tx Power Level"},
+ {"2A08", "Date Time"},
+ {"2A09", "Day of Week"},
+ {"2A0A", "Day Date Time"},
+ {"2A19", "Battery Level"},
+ {"2A1E", "Intermediate Temperature"},
+ {"2A23", "System ID"},
+ {"2A24", "Model Number String"},
+ {"2A25", "Serial Number String"},
+ {"2A26", "Firmware Revision String"},
+ {"2A27", "Hardware Revision String"},
+ {"2A28", "Software Revision String"},
+ {"2A29", "Manufacturer Name String"},
+ {"2A2A", "IEEE 11073-20601 Regulatory Certification Data List"},
+ {"2A2B", "Current Time"},
+ {"2A37", "Heart Rate Measurement"},
+ {"2A38", "Body Sensor Location"},
+ {"2A3F", "Alert Status"},
+ {"2A46", "New Alert"},
+ {"2A4A", "HID Information"},
+ {"2A4C", "HID Control Point"},
+ {"2A50", "PnP ID"},
+
+ /* Custom uuids */
+ {"7905F431-B5CE-4E99-A40F-4B1E122D00D0", "Apple Notification Center Service"},
+ {"9FBF120D-6301-42D9-8C58-25E699A21DBD", "Notifications Source"},
+ {"69D1D8F3-45E1-49A8-9821-9BBDFDAAD9D9", "Control Point"},
+ {"22EAC6E9-24D6-4BB5-BE44-B36ACE7C7BFB", "Data Source"},
+ {"89D3502B-0F36-433A-8EF4-C502AD55F8DC", "Apple Media Service"},
+ {"9B3C81D8-57B1-4A8A-B8DF-0E56F7CA51C2", "Remote Command"},
+ {"2F7CABCE-808D-411F-9A0C-BB92BA96C102", "Entity Update"},
+ {"C6B2F38C-23AB-46D8-A6AB-A3A870BBD5D7", "Entity Attribute"},
+ {"9A3F68E0-86CE-11E5-A309-0002A5D5C51B", "Samsung Gear Manager Service"},
+ {"c2f2cc0f-c085-4dd4-be5a-aca3074bbc72", "Control Point"},
+ {"cece518b-28d7-4171-92d5-76a1e249a3b9", "Notifications Source"},
+ {NULL, NULL}
+ };
+
+ if (strlen(uuid) == 36) {
+ if (!g_ascii_strncasecmp(uuid + 9, "0000-1000-8000-00805F9B34FB", 27))
+ offset = 4;
+ else {
+ offset = 0;
+ uuid_len = 36;
+ }
+ } else if (strlen(uuid) >= 8)
+ offset = 4;
+
+ for (i = 0; bt_uuid_name[i].uuid; i++) {
+ if (!g_ascii_strncasecmp(uuid + offset, bt_uuid_name[i].uuid, uuid_len)) {
+ *name = g_strdup(bt_uuid_name[i].specification_name);
+ return BT_ERROR_NONE;
+ }
+ }
+
+ *name = g_strdup("Unknown");
+ return BT_ERROR_NONE;
+}
+
/*
* Common Functions
*/
return BT_ERROR_NONE;
case BLUETOOTH_ERROR_INVALID_DATA:
case BLUETOOTH_ERROR_INVALID_PARAM:
- case BLUETOOTH_ERROR_NOT_CONNECTED:
return BT_ERROR_INVALID_PARAMETER;
+ case BLUETOOTH_ERROR_NOT_CONNECTED:
+ return BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED;
case BLUETOOTH_ERROR_NOT_SUPPORT:
return BT_ERROR_NOT_SUPPORTED;
case BLUETOOTH_ERROR_MEMORY_ALLOCATION:
case BLUETOOTH_ERROR_ALREADY_INITIALIZED:
case BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST:
case BLUETOOTH_ERROR_ALREADY_DEACTIVATED:
+ case BLUETOOTH_ERROR_ALREADY_CONNECT:
return BT_ERROR_ALREADY_DONE;
case BLUETOOTH_ERROR_NOT_PAIRED:
return BT_ERROR_REMOTE_DEVICE_NOT_BONDED;
return BT_ERROR_SERVICE_NOT_FOUND;
case BLUETOOTH_ERROR_NOT_INITIALIZED:
return BT_ERROR_NOT_INITIALIZED;
+ case BLUETOOTH_ERROR_NO_RESOURCES:
+ return BT_ERROR_QUOTA_EXCEEDED;
+ case BLUETOOTH_ERROR_AUTHENTICATION_REJECTED:
+ return BT_ERROR_AUTH_REJECTED;
case BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION:
return BT_ERROR_DEVICE_POLICY_RESTRICTION;
case BLUETOOTH_ERROR_PARING_FAILED:
case BLUETOOTH_ERROR_MAX_CONNECTION:
- case BLUETOOTH_ERROR_ALREADY_CONNECT:
- case BLUETOOTH_ERROR_NO_RESOURCES:
case BLUETOOTH_ERROR_REGISTRATION_FAILED:
case BLUETOOTH_ERROR_CONNECTION_BUSY:
case BLUETOOTH_ERROR_MAX_CLIENT:
else
(*dest_dev)->remote_name = NULL;
+#if 0
+ (*dest_dev)->is_alias_set = source_dev->is_alias_set;
+ BT_DBG("is_alias_set: [%s]", (*dest_dev)->is_alias_set ? "TRUE" : "FALSE");
+#endif
+
_bt_convert_address_to_string(&((*dest_dev)->remote_address), &(source_dev->device_address));
(*dest_dev)->bt_class.major_device_class = source_dev->device_class.major_class;
return "SERVICE_NOT_FOUND"; /* LCOV_EXCL_LINE */
case BT_ERROR_NOT_SUPPORTED:
return "NOT_SUPPORTD"; /* LCOV_EXCL_LINE */
+ case BT_ERROR_NO_DATA:
+ return "NO_DATA";
+ case BT_ERROR_QUOTA_EXCEEDED:
+ return "QUOTA EXCEEDED";
+ case BT_ERROR_AGAIN:
+ return "AGAIN";
case BT_ERROR_DEVICE_POLICY_RESTRICTION:
return "DEVICE_POLICY_RESTRICTION";
default:
}
}
+char *_bt_convert_uuid_to_uuid128(const char *uuid)
+{
+ int len;
+ char *uuid128;
+
+ len = strlen(uuid);
+
+ switch (len) {
+ case 4: /* UUID 16bits */
+ uuid128 = g_strdup_printf("0000%s-0000-1000-8000-00805f9b34fb", uuid);
+ break;
+
+ case 8: /* UUID 32bits */
+ uuid128 = g_strdup_printf("%s-0000-1000-8000-00805f9b34fb", uuid);
+ break;
+
+ case 36: /* UUID 128bits */
+ uuid128 = strdup(uuid);
+ break;
+
+ default:
+ return NULL;
+ }
+
+ return uuid128;
+}
+
bt_adapter_visibility_mode_e _bt_get_bt_visibility_mode_e(bluetooth_discoverable_mode_t mode)
{
switch (mode) {
*/
/* LCOV_EXCL_START */
-static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source)
+static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source, int error)
{
int i = 0;
__bt_free_bt_device_sdp_info_s(*dest);
return BT_ERROR_OUT_OF_MEMORY;
}
+ if(error != BT_ERROR_NONE) {
+ BT_DBG("In error case, ignore other fields of service search");
+ return BT_ERROR_NONE;
+ }
if (source->service_index > 0) {
(*dest)->service_uuid = (char **)malloc(sizeof(char *) *source->service_index);
sdp_info = NULL;
}
+static int __bt_get_bt_device_att_mtu_info_s(bt_device_att_mtu_info_s **dest, bluetooth_le_att_mtu_info_t *source)
+{
+ *dest = (bt_device_att_mtu_info_s *)g_malloc0(sizeof(bt_device_att_mtu_info_s));
+ if (*dest == NULL)
+ return BT_ERROR_OUT_OF_MEMORY;
+
+ if (_bt_convert_address_to_string(&((*dest)->remote_address), &(source->device_address)) != BT_ERROR_NONE) {
+ g_free(*dest);
+ *dest = NULL;
+
+ return BT_ERROR_OUT_OF_MEMORY;
+ }
+
+ (*dest)->mtu = source->mtu;
+ (*dest)->status = source->status;
+
+ return BT_ERROR_NONE;
+}
+
static int __bt_get_bt_device_connection_info_s(bt_device_connection_info_s **dest, bt_connection_info_t *source)
{
*dest = (bt_device_connection_info_s *)g_malloc0(sizeof(bt_device_connection_info_s));
}
static bt_gatt_server_read_value_requested_cb __bt_gatt_attribute_get_read_cb(
- bt_gatt_h service, bt_gatt_h attribute, void **user_data)
+ bt_gatt_h service, bt_gatt_h attribute, bt_gatt_h *gatt_handle, void **user_data)
{
gchar *svc_path = (gchar *)service;
gchar *att_path = (gchar *)attribute;
if (g_strcmp0(chr->path, att_path) == 0) {
if (chr->read_requested_cb) {
*user_data = chr->read_requested_user_data;
+ *gatt_handle = chr;
return chr->read_requested_cb;
} else
return NULL;
if (desc && g_strcmp0(desc->path, att_path) == 0) {
if (desc->read_requested_cb) {
*user_data = desc->read_requested_user_data;
+ *gatt_handle = desc;
return desc->read_requested_cb;
} else
return NULL;
}
static bt_gatt_server_write_value_requested_cb __bt_gatt_attribute_get_value_change_cb(
- bt_gatt_h service, bt_gatt_h attribute, void **user_data)
+ bt_gatt_h service, bt_gatt_h attribute, bt_gatt_h *gatt_handle, void **user_data)
{
gchar *svc_path = (gchar *)service;
gchar *att_path = (gchar *)attribute;
if (g_strcmp0(chr->path, att_path) == 0) {
if (chr->write_value_requested_cb) {
*user_data = chr->write_value_requested_user_data;
+ *gatt_handle = chr;
return chr->write_value_requested_cb;
} else
return NULL;
if (desc && g_strcmp0(desc->path, att_path) == 0) {
if (desc->write_value_requested_cb) {
*user_data = desc->write_value_requested_user_data;
+ *gatt_handle = desc;
return desc->write_value_requested_cb;
} else
return NULL;
return NULL;
}
-static bt_gatt_server_characteristic_notification_state_changed_cb __bt_gatt_attribute_get_notification_change_cb(
- bt_gatt_h service, bt_gatt_h attribute, void **user_data)
+static bt_gatt_server_characteristic_notification_state_changed_cb
+ __bt_gatt_attribute_get_notification_change_cb(
+ bt_gatt_h service, bt_gatt_h attribute, bt_gatt_h *gatt_handle, void **user_data)
{
gchar *svc_path = (gchar *)service;
gchar *att_path = (gchar *)attribute;
if (chr && g_strcmp0(chr->path, att_path) == 0) {
if (chr->notification_changed_cb) {
*user_data = chr->notification_changed_user_data;
+ *gatt_handle = chr;
return chr->notification_changed_cb;
} else
return NULL;
}
/* LCOV_EXCL_STOP */
+static bool __bt_need_to_handle(int event)
+{
+ int event_index = -1;
+
+ switch (event) {
+ case BLUETOOTH_EVENT_ADVERTISING_STARTED:
+ case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
+ case BLUETOOTH_EVENT_GATT_CONNECTED:
+ case BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED:
+ case BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED:
+ case BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED:
+ case BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_COMPLETED:
+ case BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED:
+ return true;
+ default:
+ break;
+ }
+
+ event_index = __bt_get_cb_index(event);
+ if (event_index != -1 && bt_event_slot_container[event_index].callback)
+ return true;
+
+ return false;
+}
+
static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *user_data)
{
int call_id;
bt_le_data_length_params_t *data_length_info = NULL;
bt_ipsp_connection_info_t *bt_ipsp_iface_info = NULL;
- event_index = __bt_get_cb_index(event);
-
- if (event == BLUETOOTH_EVENT_GATT_CONNECTED) {
- const GSList *clients = NULL; /* LCOV_EXCL_START */
- const GSList *l = NULL;
- int ret;
-
- _bt_convert_address_to_string(&device_addr,
- (bluetooth_device_address_t *)(param->param_data));
-
- clients = _bt_gatt_get_client_list();
- for (l = clients; l; l = g_slist_next(l)) {
- bt_gatt_client_s *client_s = l->data;
-
- if (!g_strcmp0(client_s->remote_address, device_addr)) {
- if (client_s->services_discovered == false) {
- BT_INFO("Matched GATT Client is found");
- ret = _bt_gatt_client_update_all((bt_gatt_client_h)l->data);
- if (ret != BT_ERROR_NONE)
- BT_ERR("bluetooth_gatt_get_primary_services is failed");
- else
- client_s->services_discovered = true;
- }
- break;
- }
- }
- g_free(device_addr);
- device_addr = NULL; /* LCOV_EXCL_STOP */
- }
-
- if (event == BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED || event == BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED ||
- event == BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED || event == BLUETOOTH_EVENT_ADVERTISING_STARTED ||
- event == BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_COMPLETED || event == BLUETOOTH_EVENT_ADVERTISING_STOPPED)
- BT_INFO("NOT use bt_event_slot_container");
- else if (event_index == -1 || bt_event_slot_container[event_index].callback == NULL)
+ if (!__bt_need_to_handle(event))
return;
- memset(&rfcomm_connection, 0x00, sizeof(bt_socket_connection_s));
+ event_index = __bt_get_cb_index(event);
switch (event) {
case BLUETOOTH_EVENT_ENABLED:
((bt_adapter_connectable_changed_cb)bt_event_slot_container[event_index].callback)
(_bt_get_error_code(param->result), *(bool *)(param->param_data), bt_event_slot_container[event_index].user_data);
break;
+ case BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED: {
+ BT_INFO("bt_device_trusted_profile_cb() will be called");
+ bt_supported_profile_trusted_t *parameter = param->param_data;
+ ((bt_device_trusted_profiles_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), parameter->address, parameter->profile, parameter->supported, parameter->trusted, bt_event_slot_container[event_index].user_data);
+ break;
+ }
case BLUETOOTH_EVENT_DISCOVERY_STARTED:
BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_STARTED");
((bt_adapter_device_discovery_state_changed_cb) bt_event_slot_container[event_index].callback)
break;
case BLUETOOTH_EVENT_SERVICE_SEARCHED:
BT_INFO("bt_device_service_searched_cb() will be called");
- __bt_get_bt_device_sdp_info_s(&sdp_info, (bt_sdp_info_t *)(param->param_data));
error_code = _bt_get_error_code(param->result);
/* In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED. */
if (error_code == BT_ERROR_OPERATION_FAILED)
error_code = BT_ERROR_SERVICE_SEARCH_FAILED;
+
+ __bt_get_bt_device_sdp_info_s(&sdp_info, (bt_sdp_info_t *)(param->param_data), error_code);
+
((bt_device_service_searched_cb)bt_event_slot_container[event_index].callback)
(error_code, sdp_info, bt_event_slot_container[event_index].user_data);
__bt_free_bt_device_sdp_info_s(sdp_info);
((bt_hid_device_received_data_s *)(param->param_data), bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_GATT_CONNECTED: {
+ bt_gatt_client_s *client_s;
+ bt_gatt_connection_state_changed_cb cb = NULL;
BT_INFO("BLUETOOTH_EVENT_GATT_CONNECTED");
- gboolean connected = TRUE;
- bd_addr = (bluetooth_device_address_t *)(param->param_data);
- _bt_convert_address_to_string(&device_addr, bd_addr);
- if (_bt_get_error_code(param->result) != BT_ERROR_NONE)
- connected = FALSE;
- ((bt_gatt_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
- (_bt_get_error_code(param->result), connected, device_addr,
- bt_event_slot_container[event_index].user_data);
+ _bt_convert_address_to_string(&device_addr,
+ (bluetooth_device_address_t *)(param->param_data));
+ client_s = (bt_gatt_client_s *)_bt_gatt_get_client(device_addr);
+ if (client_s && !client_s->services_discovered) {
+ if (_bt_gatt_client_update_services(client_s) != BT_ERROR_NONE)
+ BT_ERR("_bt_gatt_client_update_services failed");
+ else
+ client_s->services_discovered = true;
}
+ if (client_s)
+ client_s->connected = true;
+ if (event_index >= 0)
+ cb = bt_event_slot_container[event_index].callback;
+ if (cb)
+ cb(_bt_get_error_code(param->result), TRUE, device_addr,
+ bt_event_slot_container[event_index].user_data);
+ g_free(device_addr);
+ device_addr = NULL;
break;
- case BLUETOOTH_EVENT_GATT_DISCONNECTED:
+ }
+ case BLUETOOTH_EVENT_GATT_DISCONNECTED: {
+ bt_gatt_client_s *client_s;
+ bt_gatt_connection_state_changed_cb cb = NULL;
BT_INFO("BLUETOOTH_EVENT_GATT_DISCONNECTED");
- bd_addr = (bluetooth_device_address_t *)(param->param_data);
- _bt_convert_address_to_string(&device_addr, bd_addr);
- ((bt_gatt_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
- (_bt_get_error_code(param->result), FALSE, device_addr,
- bt_event_slot_container[event_index].user_data);
+ _bt_convert_address_to_string(&device_addr,
+ (bluetooth_device_address_t *)(param->param_data));
+ client_s = (bt_gatt_client_s *)_bt_gatt_get_client(device_addr);
+ if (client_s)
+ client_s->connected = false;
+ if (event_index >= 0)
+ cb = bt_event_slot_container[event_index].callback;
+ if (cb)
+ cb(_bt_get_error_code(param->result), FALSE, device_addr,
+ bt_event_slot_container[event_index].user_data);
+ g_free(device_addr);
+ device_addr = NULL;
break;
+ }
#ifdef BT_ENABLE_LEGACY_GATT_CLIENT
case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED: {
BT_INFO("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
}
#endif
_bt_unset_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC);
- ret = _bt_get_error_code(param->result);
+
+ /* Send actual ATT error code to Application
+ * if param->result is not BLUETOOTH_ERROR_INTERNAL.
+ */
+ if (param->result == BLUETOOTH_ERROR_INTERNAL)
+ ret = _bt_get_error_code(param->result);
+ else
+ ret = param->result;
+
+ if (ret != BT_ERROR_NONE)
+ BT_ERR("BLUETOOTH_EVENT_GATT_WRITE_CHAR - ret [%d]", ret);
+
cb(ret, cb_data->gatt_handle, cb_data->user_data);
g_free(cb_data);
bt_gatt_read_req_t *read_req = param->param_data;
bt_gatt_server_read_value_requested_cb cb;
void *user_data = NULL;
+ bt_gatt_h gatt_handle = NULL;
cb = __bt_gatt_attribute_get_read_cb(read_req->service_handle,
- read_req->att_handle, &user_data);
+ read_req->att_handle, &gatt_handle, &user_data);
BT_INFO("BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED");
if (cb == NULL) {
}
cb(read_req->address, read_req->req_id, read_req->service_handle,
- read_req->att_handle, read_req->offset,
+ gatt_handle, read_req->offset,
user_data);
break;
}
bt_gatt_value_change_t *value_change = param->param_data;
bt_gatt_server_write_value_requested_cb cb;
void *user_data = NULL;
+ bt_gatt_h gatt_handle = NULL;
cb = __bt_gatt_attribute_get_value_change_cb(value_change->service_handle,
- value_change->att_handle, &user_data);
+ value_change->att_handle, &gatt_handle, &user_data);
BT_INFO("BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGE");
if (cb == NULL) {
}
cb(value_change->address, value_change->req_id, value_change->service_handle,
- value_change->att_handle, value_change->offset,
+ gatt_handle, value_change->offset,
(char *)value_change->att_value, value_change->val_len, user_data);
break;
}
bt_gatt_char_notify_change_t *value_change = param->param_data;
bt_gatt_server_characteristic_notification_state_changed_cb cb;
void *user_data = NULL;
+ bt_gatt_h gatt_handle = NULL;
cb = __bt_gatt_attribute_get_notification_change_cb(value_change->service_handle,
- value_change->att_handle, &user_data);
+ value_change->att_handle, &gatt_handle, &user_data);
BT_INFO("BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED");
if (cb == NULL)
return;
cb(value_change->att_notify, value_change->service_handle,
- value_change->att_handle, user_data);
+ gatt_handle, user_data);
break;
}
case BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_COMPLETED: {
break;
}
/* LCOV_EXCL_STOP */
+ case BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED: {
+ bt_gatt_service_change_t *service_change =
+ (bt_gatt_service_change_t *)(param->param_data);
+ const GSList *l = NULL;
+ bt_gatt_client_s *client = NULL;
+ bt_gatt_service_s *svc = NULL;
+
+ BT_INFO("BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED");
+
+ if (service_change == NULL) {
+ BT_ERR("service_change is NULL");
+ return;
+ }
+
+ _bt_convert_address_to_string(&device_addr,
+ &service_change->device_addr);
+
+ client = _bt_gatt_get_client(device_addr);
+ g_free(device_addr);
+ device_addr = NULL;
+
+ if (client == NULL) {
+ BT_ERR("There is NO matched client");
+ break;
+ }
+
+ if (service_change->change_type
+ == BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD) {
+ for (l = client->services; l; l = g_slist_next(l)) {
+ svc = l->data;
+ if (!g_strcmp0(svc->path, service_change->svc_path))
+ break;
+ }
+ if (l) {
+ BT_INFO("already added service : %s", svc->path);
+ break;
+ }
+
+ svc = _bt_gatt_client_add_service(client,
+ service_change->svc_path);
+ if (svc == NULL) {
+ BT_ERR("_bt_gatt_client_add_service is failed");
+ break;
+ }
+
+ if (client->connected && client->service_changed_cb)
+ client->service_changed_cb(client,
+ BT_GATT_CLIENT_SERVICE_ADDED,
+ svc->uuid,
+ client->service_changed_user_data);
+ } else {
+ char *removed_uuid = NULL;
+
+ for (l = client->services; l; l = g_slist_next(l)) {
+ svc = l->data;
+ if (!g_strcmp0(svc->path, service_change->svc_path))
+ break;
+ }
+ if (!l) {
+ BT_ERR("There is NO matched service");
+ break;
+ }
+
+ removed_uuid = g_strdup(svc->uuid);
+ bt_gatt_service_destroy((bt_gatt_h)svc);
+
+ if (client->connected && client->service_changed_cb)
+ client->service_changed_cb(client,
+ BT_GATT_CLIENT_SERVICE_REMOVED,
+ removed_uuid,
+ client->service_changed_user_data);
+ g_free(removed_uuid);
+ }
+ break;
+ }
case BLUETOOTH_EVENT_ADVERTISING_STARTED:
BT_INFO("BLUETOOTH_EVENT_ADVERTISING_STARTED");
adv_handle = (int *)(param->param_data);
bt_event_slot_container[event_index].user_data);
break;
+
+ case BLUETOOTH_EVENT_PASSKEY_NOTIFICATION: {
+ const char *address = NULL;
+ const char *passkey = NULL;
+ const char **passkey_info = param->param_data;
+ BT_INFO("BLUETOOTH_EVENT_PASSKEY_NOTIFICATION");
+
+ address = passkey_info[0];
+ passkey = passkey_info[1];
+
+ ((bt_adapter_passkey_notification_cb)bt_event_slot_container[event_index].callback)
+ (address, passkey, bt_event_slot_container[event_index].user_data);
+
+ break;
+ }
case BLUETOOTH_EVENT_IPSP_CONNECTED:
BT_INFO("BLUETOOTH_EVENT_IPSP_CONNECTED");
bt_ipsp_iface_info = (bt_ipsp_connection_info_t *)(param->param_data);
(_bt_get_error_code(param->result), FALSE, device_addr, bt_ipsp_iface_info->if_name,
bt_event_slot_container[event_index].user_data);
break;
+ case BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED: {
+ bt_device_att_mtu_info_s *mtu_info = NULL;
+
+ BT_INFO("BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED");
+ __bt_get_bt_device_att_mtu_info_s(&mtu_info, (bluetooth_le_att_mtu_info_t *)(param->param_data));
+ ((bt_device_att_mtu_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), mtu_info, bt_event_slot_container[event_index].user_data);
+ break;
+ }
case BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED:
BT_INFO("__bt_le_set_data_length_changed_cb() will be called");
data_length_info = (bt_le_data_length_params_t *)(param->param_data);
case BLUETOOTH_EVENT_HF_RING_INDICATOR:
BT_INFO("BLUETOOTH_EVENT_HF_RING_INDICATOR");
phone_number = (char *)(param->param_data);
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_RING, phone_number,
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_RINGING, phone_number,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_CALL_TERMINATED:
BT_INFO("BLUETOOTH_EVENT_HF_CALL_TERMINATED");
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_RELEASE, NULL,
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_CALL_TERMINATED, NULL,
+ bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL:
+ BT_INFO("BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL");
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_FAILED_TO_DIALING, NULL,
+ bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_HF_CALL_IDLE:
+ BT_INFO("BLUETOOTH_EVENT_HF_CALL_IDLE");
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_IDLE, NULL,
+ bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING:
+ BT_INFO("BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING");
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_INCOMING, NULL,
+ bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_HF_CALLSETUP_DIALING:
+ BT_INFO("BLUETOOTH_EVENT_HF_CALLSETUP_DIALING");
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_DIALING, NULL,
+ bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING:
+ BT_INFO("BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING");
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_ALERTING, NULL,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_CALL_STARTED:
BT_INFO("BLUETOOTH_EVENT_HF_CALL_STARTED");
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_CALL_STARTED, NULL,
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_CALL_STARTED, NULL,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_CALL_ENDED:
BT_INFO("BLUETOOTH_EVENT_HF_CALL_ENDED");
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_CALL_ENDED, NULL,
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_CALL_ENDED, NULL,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED:
BT_INFO("BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED");
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_VOICE_RECOGNITION_ENABLED, NULL,
+ ((bt_hf_remote_device_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_DEVICE_STATE_VOICE_RECOGNITON, TRUE,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED:
BT_INFO("BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED");
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_VOICE_RECOGNITION_DISABLED, NULL,
+ ((bt_hf_remote_device_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_DEVICE_STATE_VOICE_RECOGNITON, FALSE,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_CALL_WAITING:
BT_INFO("BLUETOOTH_EVENT_HF_CALL_WAITING");
phone_number = (char *)(param->param_data);
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_WAITING, phone_number,
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_WAITING, phone_number,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_CALL_ON_HOLD:
BT_INFO("BLUETOOTH_EVENT_HF_CALL_ON_HOLD");
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_HELD, NULL,
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_HELD, NULL,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_CALL_UNHOLD:
BT_INFO("BLUETOOTH_EVENT_HF_CALL_UNHOLD");
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_UNHELD, NULL,
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_UNHELD, NULL,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_CALL_SWAPPED:
BT_INFO("BLUETOOTH_EVENT_HF_CALL_SWAPPED");
- ((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
- (BT_HF_CALL_HANDLING_EVENT_SWAPPED, NULL,
+ ((bt_hf_remote_call_event_cb)bt_event_slot_container[event_index].callback)
+ (BT_HF_REMOTE_CALL_EVENT_SWAPPED, NULL,
bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_HF_VOLUME_SPEAKER: {
(call_list, bt_event_slot_container[event_index].user_data);
break;
}
+ case BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED: {
+ bluetooth_hf_ciev_device_event_t *device_event = (bluetooth_hf_ciev_device_event_t *)(param->param_data);
+
+ BT_INFO("BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED (status %d)(value %d)",
+ device_event->event, device_event->value);
+
+ ((bt_hf_remote_device_state_changed_cb)bt_event_slot_container[event_index].callback)
+ ((bt_hf_remote_device_state_e) device_event->event, device_event->value,
+ bt_event_slot_container[event_index].user_data);
+ break;
+ }
#endif
case BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED: {
BT_DBG("BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED"); /* LCOV_EXCL_LINE */
}
}
-
static void __bt_le_event_proxy(int event, bluetooth_event_param_t *param, void *user_data)
{
bt_adapter_le_device_scan_result_info_s *scan_info = NULL;
case BLUETOOTH_EVENT_GATT_WRITE_DESC:
return BT_EVENT_GATT_CLIENT_WRITE_DESCRIPTOR;
/* LCOV_EXCL_STOP */
+ case BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED:
+ return BT_EVENT_GATT_ATT_MTU_CHANGE_STATUS;
case BLUETOOTH_EVENT_ADVERTISING_STARTED:
case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
return BT_EVENT_ADVERTISING_STATE_CHANGED;
case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
return BT_EVENT_MANUFACTURER_DATA_CHANGED; /* LCOV_EXCL_LINE */
+ case BLUETOOTH_EVENT_PASSKEY_NOTIFICATION:
+ return BT_EVENT_PASSKEY_NOTIFICATION_EVENT;
case BLUETOOTH_EVENT_CONNECTABLE_CHANGED:
return BT_EVENT_CONNECTABLE_CHANGED_EVENT; /* LCOV_EXCL_LINE */
case BLUETOOTH_EVENT_IPSP_CONNECTED:
case BLUETOOTH_EVENT_IPSP_DISCONNECTED:
return BT_EVENT_IPSP_CONNECTION_STATUS; /* LCOV_EXCL_LINE */
+ case BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED:
+ return BT_EVENT_SUPPORTED_TRUSTED_PROFILE_EVENT;
case BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED:
return BT_EVENT_LE_DATA_LENGTH_CHANGED; /* LCOV_EXCL_LINE */
#ifdef TIZEN_WEARABLE
case BLUETOOTH_EVENT_HF_CALL_TERMINATED:
case BLUETOOTH_EVENT_HF_CALL_STARTED:
case BLUETOOTH_EVENT_HF_CALL_ENDED:
- case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED:
- case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED:
case BLUETOOTH_EVENT_HF_CALL_WAITING:
case BLUETOOTH_EVENT_HF_CALL_ON_HOLD:
case BLUETOOTH_EVENT_HF_CALL_UNHOLD:
case BLUETOOTH_EVENT_HF_CALL_SWAPPED:
- return BT_EVENT_HF_CALL_HANDLING_EVENT;
+ case BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL:
+ case BLUETOOTH_EVENT_HF_CALL_IDLE:
+ case BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING:
+ case BLUETOOTH_EVENT_HF_CALLSETUP_DIALING:
+ case BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING:
+ return BT_EVENT_HF_REMOTE_CALL_EVENT;
+ case BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD:
+ return BT_EVENT_HF_VENDOR_DEP_CMD_EVENT;
case BLUETOOTH_EVENT_HF_VOLUME_SPEAKER:
return BT_EVENT_HF_SPEAKER_GAIN_CHANGE;
case BLUETOOTH_EVENT_HF_CALL_STATUS:
return BT_EVENT_HF_CALL_STATUS_UPDATED_EVENT;
+ case BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED:
+ case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED:
+ case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED:
+ return BT_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED;
#endif
case BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED:
return BT_EVENT_IPSP_INIT_STATE_CHANGED;
static void bt_gatt_client_handle_destroy(bt_gatt_h gatt_handle)
{
- if (gatt_handle)
- bt_gatt_destroy(gatt_handle);
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+
+ if (handle) {
+ if (handle->type == BT_GATT_TYPE_SERVICE)
+ bt_gatt_service_destroy(gatt_handle);
+ else if (handle->type == BT_GATT_TYPE_CHARACTERISTIC)
+ bt_gatt_characteristic_destroy(gatt_handle);
+ else if (handle->type == BT_GATT_TYPE_DESCRIPTOR)
+ bt_gatt_descriptor_destroy(gatt_handle);
+ else {
+ BT_ERR("Type is invalid(type:%d)", handle->type);
+ }
+ }
}
int _bt_gatt_client_update_all(bt_gatt_client_h client)
return ret;
}
+ if (connected_link == BLUETOOTH_CONNECTED_LINK_NONE) {
+ *connected = false;
+ return BT_ERROR_NONE;
+ }
+
if (connected_link == BLUETOOTH_CONNECTED_LINK_BREDR_LE) {
*connected = true;
return BT_ERROR_NONE;
return BT_ERROR_NONE;
}
+int bt_device_set_att_mtu_changed_cb(bt_device_att_mtu_changed_cb callback, void *user_data)
+{
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_GATT_ATT_MTU_CHANGE_STATUS, callback, user_data);
+
+ return BT_ERROR_NONE;
+}
+
int bt_device_unset_bond_created_cb(void)
{
BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
_bt_unset_cb(BT_EVENT_DEVICE_CONNECTION_STATUS);
return BT_ERROR_NONE;
}
+
+int bt_device_unset_att_mtu_changed_cb(void)
+{
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_DEVICE_CONNECTION_STATUS);
+ return BT_ERROR_NONE;
+}
+
+int bt_device_enable_rssi_monitor(const char *remote_address,
+ bt_device_connection_link_type_e link_type,
+ int low_threshold, int in_range_threshold,
+ bt_rssi_monitor_enabled_cb cb_enable,
+ void *user_data_enable,
+ bt_rssi_alert_cb cb_alert,
+ void *user_data_alert)
+{
+ bluetooth_device_address_t addr_hex = { {0,} };
+ int error_code = BT_ERROR_NONE;
+ bt_rssi_threshold_t rssi_threshold = { 0, };
+ BT_DBG("Enable RSSI");
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+ rssi_threshold.high_threshold = 127;
+ rssi_threshold.low_threshold = low_threshold;
+ rssi_threshold.in_range_threshold = in_range_threshold;
+
+ error_code = _bt_get_error_code(bluetooth_enable_rssi(&addr_hex, link_type, &rssi_threshold));
+ if (error_code != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ } else {
+ _bt_set_cb(BT_EVENT_RSSI_ENABLED_EVENT, cb_enable, user_data_enable);
+ _bt_set_cb(BT_EVENT_RSSI_ALERT_EVENT, cb_alert, user_data_alert);
+ }
+
+ return error_code;
+}
+
+int bt_device_disable_rssi_monitor(const char *remote_address,
+ bt_device_connection_link_type_e link_type,
+ bt_rssi_monitor_enabled_cb cb_disable,
+ void *user_data_disable)
+{
+ bluetooth_device_address_t addr_hex = { {0,} };
+ int error_code = BT_ERROR_NONE;
+ bt_rssi_threshold_t rssi_threshold = { 0, };
+ BT_DBG("Enable RSSI");
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+ error_code = _bt_get_error_code(bluetooth_enable_rssi(&addr_hex, link_type, &rssi_threshold));
+ if (error_code != BT_ERROR_NONE)
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ else
+ _bt_set_cb(BT_EVENT_RSSI_ENABLED_EVENT, cb_disable, user_data_disable);
+
+ return error_code;
+}
+
+int bt_device_get_rssi_strength(const char *remote_address,
+ bt_device_connection_link_type_e link_type,
+ bt_rssi_strength_cb callback, void *user_data)
+{
+ bluetooth_device_address_t addr_hex = { {0,} };
+ int error_code = BT_ERROR_NONE;
+ BT_DBG("Get RSSI Strength");
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+ error_code = _bt_get_error_code(bluetooth_get_rssi_strength(&addr_hex, link_type));
+ if (error_code != BT_ERROR_NONE)
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ else
+ _bt_set_cb(BT_EVENT_GET_RSSI_EVENT, callback, user_data);
+
+ return error_code;
+}
+
+
/* LCOV_EXCL_START */
int bt_device_le_conn_update(const char *device_address,
const bt_le_conn_update_s *parameters)
return error_code;
}
+
+int bt_device_set_pin_code(const char *remote_address, const char *pin_code)
+{
+ int error_code = BT_ERROR_NONE;
+ bluetooth_device_address_t addr_hex = { {0,} };
+ bluetooth_device_pin_code_t pin = { {0} };
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+ BT_CHECK_INPUT_PARAMETER(pin_code);
+ if (strlen(pin_code) > BLUETOOTH_PIN_CODE_MAX_LENGTH) {
+ BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER);
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+ strncpy(pin.pin_code, pin_code, BLUETOOTH_PIN_CODE_MAX_LENGTH);
+ pin.pin_code[BLUETOOTH_PIN_CODE_MAX_LENGTH] = '\0';
+
+ error_code = _bt_get_error_code(bluetooth_set_pin_code(&addr_hex, &pin));
+ if (error_code != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_device_unset_pin_code(const char *remote_address)
+{
+ int error_code = BT_ERROR_NONE;
+ bluetooth_device_address_t addr_hex = { {0,} };
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ error_code = _bt_get_error_code(bluetooth_unset_pin_code(&addr_hex));
+ if (error_code != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_device_update_le_connection_mode(const char *remote_address, bt_device_le_connection_mode_e mode)
+{
+ int ret;
+ bluetooth_device_address_t addr_hex = { {0,} };
+
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+
+ if (mode < BT_DEVICE_LE_CONNECTION_MODE_BALANCED ||
+ mode > BT_DEVICE_LE_CONNECTION_MODE_LOW_ENERGY) {
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ ret = _bt_get_error_code(bluetooth_update_le_connection_mode(&addr_hex, mode));
+ if (BT_ERROR_NONE != ret)
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+
+ return ret;
+}
+
+int bt_device_request_att_mtu(const char *remote_address, unsigned int mtu)
+{
+ int ret;
+ bluetooth_device_address_t addr_hex = { {0,} };
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ ret = _bt_get_error_code(bluetooth_request_att_mtu(&addr_hex, mtu));
+ if (BT_ERROR_NONE != ret)
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+
+ return ret;
+}
+
+int bt_device_get_att_mtu(const char *remote_address, unsigned int *mtu)
+{
+ bluetooth_device_address_t addr_hex = { {0,} };
+ int ret;
+ unsigned int mtu_value = 0;
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ ret = _bt_get_error_code(bluetooth_get_att_mtu(&addr_hex, &mtu_value));
+
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+
+ *mtu = mtu_value;
+
+ return ret;
+
+}
+
+int bt_device_get_ida(const char *remote_rpa, char **id_address)
+{
+ bluetooth_device_address_t id_addr = { {0} };
+ bluetooth_device_address_t addr_hex = { {0,} };
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_rpa);
+
+ _bt_convert_address_to_hex(&addr_hex, remote_rpa);
+
+ ret = bluetooth_get_device_ida(&addr_hex, &id_addr);
+
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+
+ ret = _bt_convert_address_to_string(id_address, &id_addr);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+
+ return ret;
+}
+
+int bt_device_set_profile_trusted(const char *device_address,
+ bt_trusted_profile_t profile, bool trust)
+{
+ bluetooth_device_address_t addr_hex = { {0,} };
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(device_address);
+
+ _bt_convert_address_to_hex(&addr_hex, device_address);
+ error_code = _bt_get_error_code(bluetooth_set_profile_trusted(&addr_hex,
+ profile, trust));
+ if (error_code != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_device_get_profile_trusted(const char *device_address,
+ bt_trusted_profile_t profile, int *trust)
+{
+ bluetooth_device_address_t addr_hex = { {0,} };
+ int profile_trusted;
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(device_address);
+
+ _bt_convert_address_to_hex(&addr_hex, device_address);
+ error_code = _bt_get_error_code(bluetooth_get_profile_trusted(&addr_hex,
+ profile, &profile_trusted));
+ if (error_code != BT_ERROR_NONE) {
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ }
+ if (trust)
+ *trust = profile_trusted;
+ return error_code;
+}
+
+int bt_device_set_trusted_profile_cb(bt_device_trusted_profiles_cb callback, void *user_data)
+{
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_SUPPORTED_TRUSTED_PROFILE_EVENT, callback, user_data);
+
+ return BT_ERROR_NONE;
+}
+
+int bt_device_unset_trusted_profile_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_SUPPORTED_TRUSTED_PROFILE_EVENT);
+ return BT_ERROR_NONE;
+}
+
int bt_device_le_set_data_length(const char *remote_address,
unsigned int max_tx_Octets, unsigned int max_tx_Time)
{
static bool is_gatt_server_initialized = false;
static bool is_gatt_server_started = false;
+bt_gatt_service_s* __bt_gatt_service_create(const char *uuid,
+ bt_gatt_service_type_e type);
+
#define BT_CHECK_GATT_SUPPORT() \
{ \
BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON); \
return BT_ERROR_NONE;
}
-static char *__convert_uuid_to_uuid128(const char *uuid)
-{
- int len;
- char *uuid128;
-
- len = strlen(uuid);
-
- switch (len) {
- case 4: /* UUID 16bits */
- uuid128 = g_strdup_printf("0000%s-0000-1000-8000-00805F9B34FB",
- uuid);
- break;
-
- case 8: /* UUID 32bits */
- uuid128 = g_strdup_printf("%s-0000-1000-8000-00805F9B34FB",
- uuid);
- break;
-
- case 36: /* UUID 128bits */
- uuid128 = strdup(uuid);
- break;
-
- default:
- return NULL;
- }
-
- return uuid128;
-}
-
static int __get_gatt_handle_by_uuid(GSList *list, const char *uuid,
bt_gatt_h *gatt_handle)
{
char *uuid128_a;
char *uuid128_b;
- uuid128_a = __convert_uuid_to_uuid128(uuid);
+ uuid128_a = _bt_convert_uuid_to_uuid128(uuid);
if (uuid128_a == NULL) {
BT_ERR("Wrong type of uuid : %s", uuid);
return BT_ERROR_INVALID_PARAMETER;
for (l = list; l; l = g_slist_next(l)) {
bt_gatt_common_s *common = (bt_gatt_common_s *)l->data;
- uuid128_b = __convert_uuid_to_uuid128(common->uuid);
+ uuid128_b = _bt_convert_uuid_to_uuid128(common->uuid);
if (g_ascii_strcasecmp(uuid128_a, uuid128_b) == 0) {
g_free(uuid128_b);
break;
g_free(uuid128_b);
}
+ g_free(uuid128_a);
if (!l)
return BT_ERROR_NO_DATA;
return BT_ERROR_NONE;
}
-const GSList *_bt_gatt_get_client_list(void)
+bt_gatt_client_h _bt_gatt_get_client(const char *remote_addr)
{
- return gatt_client_list;
+ GSList *l;
+
+ for (l = gatt_client_list; l; l = g_slist_next(l)) {
+ bt_gatt_client_s *client_s = l->data;
+
+ if (client_s == NULL)
+ continue;
+
+ if (!g_strcmp0(client_s->remote_address, remote_addr))
+ return (bt_gatt_client_h)client_s;
+ }
+
+ return NULL;
}
-const GSList *_bt_gatt_get_server_list(void)
+const GSList* _bt_gatt_get_server_list(void)
{
return gatt_server_list;
}
+static void __bt_gatt_client_handle_destroy(bt_gatt_h gatt_handle)
+{
+ bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
+
+ if (handle->type == BT_GATT_TYPE_SERVICE)
+ bt_gatt_service_destroy(gatt_handle);
+ else if (handle->type == BT_GATT_TYPE_CHARACTERISTIC)
+ bt_gatt_characteristic_destroy(gatt_handle);
+ else if (handle->type == BT_GATT_TYPE_DESCRIPTOR)
+ bt_gatt_descriptor_destroy(gatt_handle);
+}
+
+bt_gatt_h _bt_gatt_client_add_service(bt_gatt_client_h client, const char *path)
+{
+ int ret;
+ bt_gatt_client_s *client_s = client;
+ bt_gatt_service_s *svc = NULL;
+ bt_gatt_service_property_t property;
+
+ if (client == NULL || path == NULL) {
+ BT_ERR("Invalid parameter");
+ return NULL;
+ }
+
+ memset(&property, 0x00, sizeof(property));
+
+ ret = bluetooth_gatt_get_service_property(path, &property);
+ ret = _bt_get_error_code(ret);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("bluetooth_gatt_get_service_property is failed");
+ return NULL;
+ }
+
+ svc = __bt_gatt_service_create(property.uuid,
+ BT_GATT_SERVICE_TYPE_PRIMARY);
+ if (svc == NULL) {
+ BT_ERR("svc is NULL");
+ return NULL;
+ }
+ svc->role = BT_GATT_ROLE_CLIENT;
+ svc->parent = (void *)client_s;
+ svc->is_included_service = false;
+ svc->path = g_strdup(path);
+
+ svc->include_handles = property.include_handles.handle;
+ property.include_handles.handle = NULL;
+
+ svc->char_handles = property.char_handle.handle;
+ property.char_handle.handle = NULL;
+
+ bluetooth_gatt_free_service_property(&property);
+
+ client_s->services = g_slist_append(client_s->services, svc);
+
+ return svc;
+}
+
+int _bt_gatt_client_update_services(bt_gatt_client_h client)
+{
+ bt_gatt_client_s *client_s = client;
+ bluetooth_device_address_t addr_hex = { {0, } };
+ bt_gatt_handle_info_t prim_svc;
+ int ret;
+ int i;
+
+ _bt_convert_address_to_hex(&addr_hex, client_s->remote_address);
+
+ ret = bluetooth_gatt_get_primary_services(&addr_hex, &prim_svc);
+ ret = _bt_get_error_code(ret);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("bluetooth_gatt_get_primary_services is failed");
+ return ret;
+ }
+
+ g_slist_free_full(client_s->services,
+ __bt_gatt_client_handle_destroy);
+ client_s->services = NULL;
+
+ if (prim_svc.count == 0) {
+ BT_INFO("There is no service");
+ return BT_ERROR_NONE;
+ }
+
+ for (i = 0; i < prim_svc.count; i++) {
+ BT_INFO("Service handle[%d] %s", i, prim_svc.handle[i]);
+
+ if (!_bt_gatt_client_add_service(client, prim_svc.handle[i]))
+ BT_ERR("_bt_gatt_client_add_service is failed [%s]",
+ prim_svc.handle[i]);
+ }
+ g_strfreev(prim_svc.handle);
+
+ return BT_ERROR_NONE;
+}
+
+int _bt_gatt_client_update_include_services(bt_gatt_h service)
+{
+ bt_gatt_service_s *svc = service;
+ GSList *include_list = NULL;
+ int i;
+
+ if (svc == NULL)
+ return BT_ERROR_INVALID_PARAMETER;
+
+ if (svc->include_handles == NULL)
+ return BT_ERROR_NONE;
+
+ for (i = 0; svc->include_handles[i]; i++) {
+ bt_gatt_service_s *sec_svc = NULL;
+ bt_gatt_service_property_t sec_property;
+ int ret;
+
+ memset(&sec_property, 0x00, sizeof(sec_property));
+
+ ret = bluetooth_gatt_get_service_property(
+ svc->include_handles[i], &sec_property);
+ ret = _bt_get_error_code(ret);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("bluetooth_gatt_get_service_property is failed");
+ continue;
+ }
+
+ sec_svc = __bt_gatt_service_create(sec_property.uuid,
+ BT_GATT_SERVICE_TYPE_SECONDARY);
+ if (sec_svc == NULL) {
+ BT_ERR("svc is NULL");
+ goto next;
+ }
+ sec_svc->role = BT_GATT_ROLE_CLIENT;
+ sec_svc->parent = (void *)svc;
+ sec_svc->is_included_service = true;
+ sec_svc->path = g_strdup(svc->include_handles[i]);
+
+ sec_svc->char_handles = sec_property.char_handle.handle;
+ sec_property.char_handle.handle = NULL;
+
+ include_list = g_slist_append(include_list, sec_svc);
+next:
+ bluetooth_gatt_free_service_property(&sec_property);
+ }
+
+ g_strfreev(svc->include_handles);
+ svc->include_handles = NULL;
+
+ g_slist_free_full(svc->included_services,
+ __bt_gatt_client_handle_destroy);
+
+ svc->included_services = include_list;
+
+ return BT_ERROR_NONE;
+}
+
+int _bt_gatt_client_update_characteristics(bt_gatt_h service)
+{
+ bt_gatt_service_s *svc = service;
+ GSList *chr_list = NULL;
+ int i;
+
+ if (svc == NULL)
+ return BT_ERROR_INVALID_PARAMETER;
+
+ if (svc->char_handles == NULL)
+ return BT_ERROR_NONE;
+
+ for (i = 0; svc->char_handles[i]; i++) {
+ bt_gatt_characteristic_s *chr = NULL;
+ bt_gatt_char_property_t char_property;
+ int ret;
+
+ memset(&char_property, 0x00, sizeof(char_property));
+
+ ret = bluetooth_gatt_get_characteristics_property(
+ svc->char_handles[i], &char_property);
+ ret = _bt_get_error_code(ret);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("bluetooth_gatt_get_characteristics_property is failed");
+ continue;
+ }
+
+ ret = bt_gatt_characteristic_create(char_property.uuid, 0,
+ char_property.permission,
+ (char *)char_property.val,
+ (int)char_property.val_len, (bt_gatt_h *)&chr);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("bt_gatt_characteristic_create is failed");
+ goto next;
+ }
+
+ if (char_property.permission & BT_GATT_PROPERTY_WRITE_WITHOUT_RESPONSE)
+ chr->write_type = BT_GATT_WRITE_TYPE_WRITE_NO_RESPONSE;
+ else if (char_property.permission & BT_GATT_PROPERTY_WRITE)
+ chr->write_type = BT_GATT_WRITE_TYPE_WRITE;
+
+ chr->path = g_strdup(svc->char_handles[i]);
+ chr->parent = (void *)svc;
+ chr->role = BT_GATT_ROLE_CLIENT;
+ chr->desc_handles = char_property.char_desc_handle.handle;
+ char_property.char_desc_handle.handle = NULL;
+
+ chr_list = g_slist_append(chr_list, chr);
+next:
+ bluetooth_gatt_free_char_property(&char_property);
+ }
+
+ g_strfreev(svc->char_handles);
+ svc->char_handles = NULL;
+
+ g_slist_free_full(svc->characteristics,
+ __bt_gatt_client_handle_destroy);
+
+ svc->characteristics = chr_list;
+
+ return BT_ERROR_NONE;
+}
+
+int _bt_gatt_client_update_descriptors(bt_gatt_h characteristic)
+{
+ bt_gatt_characteristic_s *chr = characteristic;
+ GSList *desc_list = NULL;
+ int i;
+
+ if (chr == NULL)
+ return BT_ERROR_INVALID_PARAMETER;
+
+ if (chr->desc_handles == NULL)
+ return BT_ERROR_NONE;
+
+ for (i = 0; chr->desc_handles[i]; i++) {
+ bt_gatt_descriptor_s *desc = NULL;
+ bt_gatt_char_descriptor_property_t desc_property;
+ int ret;
+
+ memset(&desc_property, 0x00, sizeof(desc_property));
+
+ ret = bluetooth_gatt_get_char_descriptor_property(
+ chr->desc_handles[i], &desc_property);
+ ret = _bt_get_error_code(ret);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("bluetooth_gatt_get_char_descriptor_property is failed");
+ continue;
+ }
+
+ ret = bt_gatt_descriptor_create(desc_property.uuid, 0,
+ (char*)desc_property.val,
+ (int)desc_property.val_len,
+ (bt_gatt_h *)&desc);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("bt_gatt_characteristic_create is failed");
+ goto next;
+ }
+
+ desc->path = g_strdup(chr->desc_handles[i]);
+ desc->parent = (void *)characteristic;
+ desc->role = BT_GATT_ROLE_CLIENT;
+
+ desc_list = g_slist_append(desc_list, desc);
+next:
+ bluetooth_gatt_free_desc_property(&desc_property);
+ }
+
+ g_strfreev(chr->desc_handles);
+ chr->desc_handles = NULL;
+
+ g_slist_free_full(chr->descriptors,
+ __bt_gatt_client_handle_destroy);
+
+ chr->descriptors = desc_list;
+
+ return BT_ERROR_NONE;
+}
+
#ifdef BT_ENABLE_LEGACY_GATT_CLIENT
bool _bt_gatt_is_legacy_client_mode(void)
{
_bt_unset_cb(BT_EVENT_GATT_CONNECTION_STATUS);
return BT_ERROR_NONE;
}
-/* LCOV_EXCL_START */
-int bt_gatt_get_uuid_specification_name(const char *uuid, char **name)
-{
- BT_CHECK_GATT_SUPPORT();
- BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(uuid);
- BT_CHECK_INPUT_PARAMETER(name);
-
- int i;
- int offset = 0;
- static struct {
- const char *uuid;
- const char *specification_name;
- } bt_uuid_name[] = {
- /* GATT Services */
- {"1800", "Generic Access"},
- {"1801", "Generic Attribute"},
- {"1802", "Immediate Alert"},
- {"1803", "Link Loss"},
- {"1804", "Tx Power"},
- {"1805", "Current Time Service"},
- {"1806", "Reference Time Update Service"},
- {"1807", "Next DST Change Service"},
- {"1808", "Glucose"},
- {"1809", "Health Thermometer"},
- {"180A", "Device Information"},
- {"180D", "Heart Rate"},
- {"180F", "Battery Service"},
- {"1810", "Blood Pressure"},
- {"1811", "Alert Notification Service"},
- {"1812", "Human Interface Device"},
-
- /* GATT Declarations */
- {"2800", "Primary Service Declaration"},
- {"2801", "Secondary Service Declaration"},
- {"2802", "Include Declaration"},
- {"2803", "Characteristic Declaration"},
-
- /* GATT Descriptors */
- {"2900", "Characteristic Extended Properties"},
- {"2901", "Characteristic User Description"},
- {"2902", "Client Characteristic Configuration"},
- {"2903", "Server Characteristic Configuration"},
- {"2904", "Characteristic Format"},
- {"2905", "Characteristic Aggregate Formate"},
- {"2906", "Valid Range"},
- {"2907", "External Report Reference"},
- {"2908", "Report Reference"},
-
- /* GATT Characteristics */
- {"2A00", "Device Name"},
- {"2A01", "Appearance"},
- {"2A02", "Peripheral Privacy Flag"},
- {"2A03", "Reconnection Address"},
- {"2A04", "Peripheral Preferred Connection Parameters"},
- {"2A05", "Service Changed"},
- {"2A06", "Alert Level"},
- {"2A07", "Tx Power Level"},
- {"2A08", "Date Time"},
- {"2A09", "Day of Week"},
- {"2A0A", "Day Date Time"},
- {"2A19", "Battery Level"},
- {"2A1E", "Intermediate Temperature"},
- {"2A23", "System ID"},
- {"2A24", "Model Number String"},
- {"2A25", "Serial Number String"},
- {"2A26", "Firmware Revision String"},
- {"2A27", "Hardware Revision String"},
- {"2A28", "Software Revision String"},
- {"2A29", "Manufacturer Name String"},
- {"2A2A", "IEEE 11073-20601 Regulatory Certification Data List"},
- {"2A2B", "Current Time"},
- {"2A37", "Heart Rate Measurement"},
- {"2A38", "Body Sensor Location"},
- {"2A3F", "Alert Status"},
- {"2A46", "New Alert"},
- {"2A4A", "HID Information"},
- {"2A4C", "HID Control Point"},
- {"2A50", "PnP ID"},
- {NULL, NULL}
- };
-
- if (strlen(uuid) >= 8)
- offset = 4;
-
- for (i = 0; bt_uuid_name[i].uuid; i++) {
- if (!g_ascii_strncasecmp(uuid + offset,
- bt_uuid_name[i].uuid, 4)) {
- *name = g_strdup(bt_uuid_name[i].specification_name);
- return BT_ERROR_NONE;
- }
- }
-
- *name = g_strdup("Unknown");
- return BT_ERROR_NONE;
-}
static void __bt_gatt_free_descriptor(bt_gatt_h gatt_handle)
{
static void __bt_gatt_free_characteristic(bt_gatt_h gatt_handle)
{
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ int ret;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
+
+ if (chr->role == BT_GATT_ROLE_CLIENT && chr->value_changed_cb &&
+ chr->properties &
+ (BT_GATT_PROPERTY_NOTIFY | BT_GATT_PROPERTY_INDICATE)) {
+ BT_DBG("Unwatch characteristic");
+ ret = _bt_get_error_code(bluetooth_gatt_unwatch_characteristics(
+ chr->path));
+ if (ret != BT_ERROR_NONE)
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ }
g_slist_free_full(chr->descriptors, __bt_gatt_free_descriptor);
+ g_strfreev(chr->desc_handles);
+
g_free(chr->path);
g_free(chr->uuid);
g_free(chr->value);
_bt_convert_error_to_string(ret), ret);
}
+ g_strfreev(svc->include_handles);
+ g_strfreev(svc->char_handles);
+
g_free(svc->path);
g_free(svc->uuid);
g_free(svc);
}
}
-int bt_gatt_destroy(bt_gatt_h gatt_handle)
-{
- bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
-
- BT_CHECK_GATT_SUPPORT();
- BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(gatt_handle);
-
- if (handle->type == BT_GATT_TYPE_SERVICE)
- __bt_gatt_destroy_service(gatt_handle);
- else if (handle->type == BT_GATT_TYPE_CHARACTERISTIC)
- __bt_gatt_destroy_characteristic(gatt_handle);
- else if (handle->type == BT_GATT_TYPE_DESCRIPTOR)
- __bt_gatt_destroy_descriptor(gatt_handle);
- else {
- BT_ERR("Type is invalid(type:%d)", handle->type);
- return BT_ERROR_INVALID_PARAMETER;
- }
-
- return BT_ERROR_NONE;
-}
-
int bt_gatt_service_destroy(bt_gatt_h gatt_handle)
{
bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
return BT_ERROR_NONE; /* LCOV_EXCL_LINE */
}
+
+bt_gatt_service_s* __bt_gatt_service_create(const char *uuid,
+ bt_gatt_service_type_e type)
+{
+ bt_gatt_service_s *svc;
+
+ if (uuid == NULL)
+ return NULL;
+
+ svc = (bt_gatt_service_s*)g_malloc0(sizeof(bt_gatt_service_s));
+ if (svc == NULL)
+ return NULL;
+
+ svc->type = BT_GATT_TYPE_SERVICE;
+ if (strlen(uuid) == 8)
+ svc->uuid = _bt_convert_uuid_to_uuid128(uuid);
+ else
+ svc->uuid = strdup(uuid);
+ if (svc->uuid == NULL) {
+ g_free(svc);
+ return NULL;
+ }
+ svc->service_type = type;
+
+ return svc;
+}
+
/* LCOV_EXCL_START */
int bt_gatt_service_create(const char *uuid, bt_gatt_service_type_e type,
bt_gatt_h *service)
BT_CHECK_INPUT_PARAMETER(uuid);
BT_CHECK_INPUT_PARAMETER(service);
- svc = (bt_gatt_service_s *)g_malloc0(sizeof(bt_gatt_service_s));
- if (svc == NULL)
- return BT_ERROR_OUT_OF_MEMORY;
- svc->type = BT_GATT_TYPE_SERVICE;
- svc->role = BT_GATT_ROLE_SERVER;
-
if (is_gatt_server_started) {
BT_ERR("Already Server started");
return BT_ERROR_OPERATION_FAILED;
}
- if (strlen(uuid) == 8)
- svc->uuid = __convert_uuid_to_uuid128(uuid);
- else
- svc->uuid = strdup(uuid);
- if (svc->uuid == NULL) {
- g_free(svc);
+ svc = __bt_gatt_service_create(uuid, type);
+ if (svc == NULL)
return BT_ERROR_OUT_OF_MEMORY;
- }
+ svc->role = BT_GATT_ROLE_SERVER;
svc->is_included_service = false;
- svc->service_type = type;
*service = (bt_gatt_h)svc;
BT_CHECK_INPUT_PARAMETER(uuid); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(characteristic);
- ret = __get_gatt_handle_by_uuid(svc->characteristics,
- uuid, &gatt_handle);
+ if (svc->char_handles) {
+ ret = _bt_gatt_client_update_characteristics(svc);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("_bt_gatt_client_update_characteristics failed");
+ return ret;
+ }
+ }
+
+ ret = __get_gatt_handle_by_uuid(svc->characteristics, uuid, &gatt_handle);
if (ret == BT_ERROR_NONE && gatt_handle != NULL) {
*characteristic = gatt_handle;
return BT_ERROR_NONE;
BT_CHECK_INPUT_PARAMETER(service);
BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
+ if (svc->char_handles) {
+ int ret;
+
+ ret = _bt_gatt_client_update_characteristics(svc);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("_bt_gatt_client_update_characteristics is failed");
+ return ret;
+ }
+ }
+
total = g_slist_length(svc->characteristics);
for (l = svc->characteristics; l; l = g_slist_next(l)) {
BT_CHECK_INPUT_PARAMETER(uuid); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(included_service);
- ret = __get_gatt_handle_by_uuid(svc->included_services,
- uuid, &gatt_handle);
+ if (svc->include_handles) {
+ ret = _bt_gatt_client_update_include_services(svc);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("_bt_gatt_client_update_include_services failed");
+ return ret;
+ }
+ }
+
+ ret = __get_gatt_handle_by_uuid(svc->included_services, uuid, &gatt_handle);
if (ret == BT_ERROR_NONE && gatt_handle != NULL) {
*included_service = gatt_handle;
return BT_ERROR_NONE;
BT_CHECK_INPUT_PARAMETER(service);
BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_LINE */
+ if (svc->include_handles) {
+ int ret;
+
+ ret = _bt_gatt_client_update_include_services(svc);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("_bt_gatt_client_update_include_services failed");
+ return ret;
+ }
+ }
+
total = g_slist_length(svc->included_services); /* LCOV_EXCL_LINE */
for (l = svc->included_services; l; l = g_slist_next(l)) {
chr->type = BT_GATT_TYPE_CHARACTERISTIC;
chr->role = BT_GATT_ROLE_SERVER;
if (strlen(uuid) == 8)
- chr->uuid = __convert_uuid_to_uuid128(uuid);
+ chr->uuid = _bt_convert_uuid_to_uuid128(uuid);
else
chr->uuid = g_strdup(uuid);
if (chr->uuid == NULL) {
bt_gatt_write_type_e write_type)
{
bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)characteristic;
+ int property;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
- chr->write_type = write_type;
+ switch (write_type) {
+ case BT_GATT_WRITE_TYPE_WRITE:
+ property = BT_GATT_PROPERTY_WRITE;
+ break;
+ case BT_GATT_WRITE_TYPE_WRITE_NO_RESPONSE:
+ property = BT_GATT_PROPERTY_WRITE_WITHOUT_RESPONSE;
+ break;
+/* After ACR for BT_GATT_WRITE_TYPE_SIGNED_WRITE, will enable this code */
+#if 0
+ case BT_GATT_WRITE_TYPE_SIGNED_WRITE:
+ property = BT_GATT_PROPERTY_AUTHENTICATED_SIGNED_WRITES;
+ break;
+#endif
+ default:
+ return BT_ERROR_NOT_SUPPORTED;
+ }
+
+ if(!(chr->properties & property))
+ return BT_ERROR_NOT_SUPPORTED;
+ chr->write_type = write_type;
return BT_ERROR_NONE;
}
BT_CHECK_INPUT_PARAMETER(uuid); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(descriptor);
+ if (chr->type != BT_GATT_TYPE_CHARACTERISTIC) {
+ BT_ERR("Wrong type of GATT handle : %d", chr->type);
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+
+ if (chr->desc_handles) {
+ ret = _bt_gatt_client_update_descriptors(chr);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("_bt_gatt_client_update_descriptors is failed");
+ return ret;
+ }
+ }
+
ret = __get_gatt_handle_by_uuid(chr->descriptors, uuid, &gatt_handle);
if (ret == BT_ERROR_NONE && gatt_handle != NULL) {
*descriptor = gatt_handle;
return BT_ERROR_INVALID_PARAMETER;
}
+ if (chr->desc_handles) {
+ int ret;
+
+ ret = _bt_gatt_client_update_descriptors(chr);
+ if (ret != BT_ERROR_NONE) {
+ BT_ERR("_bt_gatt_client_update_descriptors is failed");
+ return ret;
+ }
+ }
+
total = g_slist_length(chr->descriptors);
i = 1;
desc->type = BT_GATT_TYPE_DESCRIPTOR;
desc->role = BT_GATT_ROLE_SERVER;
if (strlen(uuid) == 8)
- desc->uuid = __convert_uuid_to_uuid128(uuid);
+ desc->uuid = _bt_convert_uuid_to_uuid128(uuid);
else
desc->uuid = g_strdup(uuid);
if (desc->uuid == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
goto fail;
}
+
desc->permissions = permissions;
desc->value_length = value_length;
if (value_length > 0) {
return BT_ERROR_SERVICE_NOT_FOUND;
}
- __bt_gatt_destroy_service(svc);
+ bt_gatt_service_destroy(svc);
return BT_ERROR_NONE;
}
int bt_gatt_server_unregister_all_services(bt_gatt_server_h server)
{
- bt_gatt_server_s *serv = (bt_gatt_server_s *)server;
int ret = BT_ERROR_NONE;
+ bt_gatt_server_s *serv = (bt_gatt_server_s*)server;
+
BT_CHECK_INIT_STATUS();
BT_CHECK_GATT_SERVER_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(server);
int ret = BT_ERROR_NONE;
BT_CHECK_INIT_STATUS();
- if (value_length < 0)
- return BT_ERROR_INVALID_PARAMETER;
+ if (request_type == BLUETOOTH_GATT_REQUEST_TYPE_READ &&
+ resp_status == BT_ERROR_NONE) {
+ BT_CHECK_INPUT_PARAMETER(value);
+
+ if (value_length < 0)
+ return BT_ERROR_INVALID_PARAMETER;
+ }
ret = _bt_get_error_code(bluetooth_gatt_send_response(request_id,
request_type, resp_status,
{
int ret = BT_ERROR_NONE;
bt_gatt_client_s *client_s;
+ bool connected = false;
GSList *l;
BT_CHECK_GATT_SUPPORT();
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
return ret;
}
- memset(client_s, 0x00, sizeof(*client_s));
client_s->remote_address = g_strdup(remote_address);
if (client_s->remote_address == NULL) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
return ret;
}
- client_s->services_discovered = false;
*client = (bt_gatt_client_h)client_s;
gatt_client_list = g_slist_append(gatt_client_list, client_s);
+ if (bt_device_is_profile_connected(remote_address, BT_PROFILE_GATT,
+ &connected) != BT_ERROR_NONE)
+ BT_ERR("bt_device_is_profile_connected is failed");
+ else
+ client_s->connected = connected;
+
+ if (_bt_gatt_client_update_services(*client) == BT_ERROR_NONE)
+ client_s->services_discovered = true;
- if (_bt_gatt_client_update_all(*client) == BT_ERROR_NONE)
- client_s->services_discovered = true;
+ BT_INFO("GATT Client Handle is created");
return ret; /* LCOV_EXCL_STOP */
}
chr->path, (guint8 *)chr->value,
chr->value_length,
BT_GATT_PROPERTY_WRITE_WITHOUT_RESPONSE));
+/* After ACR for BT_GATT_WRITE_TYPE_SIGNED_WRITE, will enable this code */
+#if 0
+
+ else if (chr->write_type == BT_GATT_WRITE_TYPE_SIGNED_WRITE)
+ ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value_by_type(
+ chr->path, (guint8 *)chr->value, chr->value_length,
+ BT_GATT_PROPERTY_AUTHENTICATED_SIGNED_WRITES));
+#endif
else {
BT_ERR("Unknow write type : %d", chr->write_type);
+ BT_ERR("path : %s", chr->path);
ret = BT_ERROR_OPERATION_FAILED;
}
if (ret != BT_ERROR_NONE) {
g_free(cb_data);
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
- if (chr->write_type != BT_GATT_WRITE_TYPE_WRITE_NO_RESPONSE)
- _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC,
- callback, cb_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC, callback, cb_data);
}
} else if (c->type == BT_GATT_TYPE_DESCRIPTOR) {
bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
desc->value_length));
if (ret != BT_ERROR_NONE) {
g_free(cb_data);
- BT_ERR("%s(0x%08x)",
- _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
- _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_DESCRIPTOR,
- callback, cb_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_DESCRIPTOR, callback, cb_data);
}
} else {
BT_ERR("Invalid handle type for write ");
if (ret <= 0) {
if (ret == -1) {
/* write fail case */
- if (errno == EACCES || errno == EPERM)
+ if (errno == EACCES || errno == EPERM) {
set_last_result(BT_ERROR_PERMISSION_DENIED);
- else if (errno == EAGAIN || errno == EWOULDBLOCK)
+ BT_ERR("PERMISSION_DENIED, errno = %d", errno);
+ } else if (errno == EAGAIN || errno == EWOULDBLOCK) {
set_last_result(BT_ERROR_AGAIN);
- else
+ BT_ERR("BT_ERROR_AGAIN, errno = %d", errno);
+ } else {
set_last_result(BT_ERROR_OPERATION_FAILED);
+ BT_ERR("BT_ERROR_OPERATION_FAILED, errno = %d", errno);
+ }
} else {
ret = _bt_get_error_code(ret);
set_last_result(ret);
+ BT_ERR("Write failed, ret = %d", ret);
}
-
- BT_ERR("Write failed, ret = %d", ret);
}
return ret;
BT_CHECK_HID_DEVICE_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(remote_address);
+ BT_CHECK_INPUT_PARAMETER(data);
ret = bluetooth_hid_device_reply_to_report(remote_address, header_type,
param_type, data, data_len);
if (ret <= 0) {
if (ret == -1) {
/* write fail case */
- if (errno == EACCES || errno == EPERM)
+ if (errno == EACCES || errno == EPERM) {
set_last_result(BT_ERROR_PERMISSION_DENIED);
- else if (errno == EAGAIN || errno == EWOULDBLOCK)
+ BT_ERR("PERMISSION_DENIED, errno = %d", errno);
+ } else if (errno == EAGAIN || errno == EWOULDBLOCK) {
set_last_result(BT_ERROR_AGAIN);
- else
+ BT_ERR("BT_ERROR_AGAIN, errno = %d", errno);
+ } else {
set_last_result(BT_ERROR_OPERATION_FAILED);
+ BT_ERR("BT_ERROR_OPERATION_FAILED, errno = %d", errno);
+ }
} else {
ret = _bt_get_error_code(ret);
set_last_result(ret);
+ BT_ERR("Write failed, ret = %d", ret);
}
-
- BT_ERR("Write failed, ret = %d", ret);
}
return ret;
if (ret <= 0) {
if (ret == -1) {
/* write fail case */
- if (errno == EACCES || errno == EPERM)
+ if (errno == EACCES || errno == EPERM) {
set_last_result(BT_ERROR_PERMISSION_DENIED);
- else if (errno == EAGAIN || errno == EWOULDBLOCK)
+ BT_ERR("PERMISSION_DENIED, errno = %d", errno);
+ } else if (errno == EAGAIN || errno == EWOULDBLOCK) {
set_last_result(BT_ERROR_AGAIN);
- else
+ BT_ERR("BT_ERROR_AGAIN, errno = %d", errno);
+ } else {
set_last_result(BT_ERROR_OPERATION_FAILED);
+ BT_ERR("BT_ERROR_OPERATION_FAILED, errno = %d", errno);
+ }
} else {
ret = _bt_get_error_code(ret);
set_last_result(ret);
+ BT_ERR("Write failed, ret = %d", ret);
}
-
- BT_ERR("Write failed, ret = %d", ret);
}
return ret; /* LCOV_EXCL_STOP */
char *str = NULL;
bt_gatt_get_uuid(gatt_handle, &uuid);
- bt_gatt_get_uuid_specification_name(uuid, &str);
+ bt_get_uuid_name(uuid, &str);
TC_PRT("[%d / %d] %s (%s)",
index, total,
char *str = NULL;
bt_gatt_get_uuid(gatt_handle, &uuid);
- bt_gatt_get_uuid_specification_name(uuid, &str);
+ bt_get_uuid_name(uuid, &str);
TC_PRT("Write %s for %s (%s)",
result == BT_ERROR_NONE ? "Success" : "Fail",
char *str = NULL;
bt_gatt_get_uuid(gatt_handle, &uuid);
- bt_gatt_get_uuid_specification_name(uuid, &str);
+ bt_get_uuid_name(uuid, &str);
TC_PRT("Read %s for %s (%s)",
result == BT_ERROR_NONE ? "Success" : "Fail",
char *str = NULL;
bt_gatt_get_uuid(desc_handle, &uuid);
- bt_gatt_get_uuid_specification_name(uuid, &str);
+ bt_get_uuid_name(uuid, &str);
TC_PRT("\t\t[%d / %d] %s (%s)",
index, total,
int ret;
char *uuid = NULL;
char *str = NULL;
+ int properties = 0;
bt_gatt_get_uuid(chr_handle, &uuid);
- bt_gatt_get_uuid_specification_name(uuid, &str);
+ bt_get_uuid_name(uuid, &str);
+ bt_gatt_characteristic_get_properties(chr_handle, &properties);
- TC_PRT("\t[%d / %d] %s (%s)",
- index, total,
- str ? str : "Unknown", uuid);
+ TC_PRT("\t[%d / %d] %s (%s) (0x%X)", index, total, str ? str : "Unknown", uuid, properties);
__bt_gatt_client_print_value(chr_handle);
g_free(str);
char *str = NULL;
bt_gatt_get_uuid(svc_handle, &uuid);
- bt_gatt_get_uuid_specification_name(uuid, &str);
+ bt_get_uuid_name(uuid, &str);
TC_PRT("[%d / %d] %s (%s)",
index, total,
char *str = NULL;
bt_gatt_get_uuid(svc_handle, &uuid);
- bt_gatt_get_uuid_specification_name(uuid, &str);
+ bt_get_uuid_name(uuid, &str);
if (!g_strcmp0(uuid, HPS_UUID)) {
char *str = NULL;
bt_gatt_get_uuid(svc_handle, &uuid);
- bt_gatt_get_uuid_specification_name(uuid, &str);
+ bt_get_uuid_name(uuid, &str);
TC_PRT("[%d / %d] %s (%s)", index, total, str ? str : "Unknown", uuid);
bt_gatt_get_characteristic_declaration(service, &uuid,
&value, &value_length);
- bt_gatt_get_uuid_specification_name(uuid, &name);
+ bt_get_uuid_name(uuid, &name);
TC_PRT("uuid: %s [%s]", uuid, name);
g_free(uuid);
if (ret < BT_ERROR_NONE) {
TC_PRT("returns %s\n", __bt_get_error_message(ret));
} else {
- bt_gatt_get_uuid_specification_name(uuid, &name);
+ bt_get_uuid_name(uuid, &name);
TC_PRT("uuid: %s [%s]", uuid, name);
g_free(name);
g_free(uuid);
if (ret < BT_ERROR_NONE) {
TC_PRT("returns %s\n", __bt_get_error_message(ret));
} else {
- bt_gatt_get_uuid_specification_name(uuid, &name);
+ bt_get_uuid_name(uuid, &name);
TC_PRT("uuid: %s [%s]", uuid, name);
for (i = 0; i < value_length; i++)
projects / platform / core / api / bluetooth.git / commitdiff