/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the License);
* you may not use this file except in compliance with the License.
return BT_ERROR_NOT_INITIALIZED; \
}
+#define BT_OTP_SERVICE_UUID "00001825-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_FEATURE_UUID "00002abd-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OACP_CONTROL_POINT_UUID "00002ac5-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OLCP_CONTROL_POINT_UUID "00002ac6-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OBJECT_NAME_UUID "00002abe-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OBJECT_TYPE_UUID "00002abf-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OBJECT_SIZE_UUID "00002ac0-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OBJECT_FIRST_CREATED_UUID "00002ac1-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OBJECT_LAST_MODIFIED_UUID "00002ac2-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OBJECT_ID_UUID "00002ac3-0000-1000-8000-00805f9b34fb"
+#define BT_OTP_OBJECT_PROP_UUID "00002ac4-0000-1000-8000-00805f9b34fb"
+
+#define BT_ADDR_LENGTH 18
+#define BT_OTP_FEATURE_LENGTH 8
+
+#define IS_OACP_SUPPORTED(feature) feature & 0xffffffff00000000
+#define IS_OLCP_SUPPORTED(feature) feature & 0x00000000ffffffff
+
+typedef struct {
+ char *remote_address;
+ bool connected;
+
+ const void *connection_callback;
+ void *conn_cb_user_data;
+
+ char *otp_service_handle; /* OTP Service Handle */
+ char *otp_feature_obj_path; /* OTP feature characteristic handle */
+ uint64_t otp_feature; /* OTP feature value */
+ char *otp_oacp_control_point; /* OTP OACP Control Point characteristic handle */
+ char *otp_oacp_cccd; /* OTP OACP Control Point CCCD handle */
+ char *otp_olcp_control_point; /* OTP OLCP Control Point characteristic handle */
+ char *otp_olcp_cccd; /* OTP OLCP Control Point CCCD handle */
+
+ /* Object Metadata paths */
+ char *otp_name_obj_path; /* OTP Object Name characteristic handle */
+ char *otp_type_obj_path; /* OTP Object Type characteristic handle */
+ char *otp_size_obj_path; /* OTP Object Size characteristic handle */
+ char *otp_first_created_obj_path; /* OTP Object Frist Created characteristic handle */
+ char *otp_last_modified_obj_path; /* OTP Object Last Modified characteristic handle */
+ char *otp_id_obj_path; /* OTP Object ID characteristic handle */
+ char *otp_props_obj_path; /* OTP Object Properties characteristic handle */
+
+ bool oacp_cccd_enabled; /* OTP OACP Control Point CCCD is enabled or not */
+ bool olcp_cccd_enabled; /* OTP OLCP Control Point CCCD is enabled or not */
+} bt_otp_client_s;
+
+GSList *otp_client_list;
static bool is_otp_server_initialized = false;
int __bt_check_otp_server_init_status(void)
if (_bt_check_cb(BT_EVENT_OTP_SERVER_STATE_CHANGED) == true)
_bt_unset_cb(BT_EVENT_OTP_SERVER_STATE_CHANGED);
return BT_ERROR_NONE;
-}
\ No newline at end of file
+}
+
+static bt_otp_client_s *_bt_otp_client_find(const char *remote_address)
+{
+ GSList *l;
+
+ for (l = otp_client_list; l; l = g_slist_next(l)) {
+
+ if (!g_ascii_strcasecmp(((bt_otp_client_s *)l->data)->remote_address, remote_address))
+ return ((bt_otp_client_s *)l->data);
+ }
+ return NULL;
+}
+
+char *free_object_path(char *path)
+{
+ if (path)
+ g_free(path);
+ return NULL;
+}
+
+static void __bt_otp_client_reset_server_data(bt_otp_client_s *otp_client_s)
+{
+ otp_client_s->otp_service_handle =
+ free_object_path(otp_client_s->otp_service_handle);
+ otp_client_s->otp_feature_obj_path =
+ free_object_path(otp_client_s->otp_feature_obj_path);
+ otp_client_s->otp_oacp_control_point =
+ free_object_path(otp_client_s->otp_oacp_control_point);
+ otp_client_s->otp_oacp_cccd =
+ free_object_path(otp_client_s->otp_oacp_cccd);
+ otp_client_s->otp_olcp_control_point =
+ free_object_path(otp_client_s->otp_olcp_control_point);
+ otp_client_s->otp_olcp_cccd =
+ free_object_path(otp_client_s->otp_olcp_cccd);
+ otp_client_s->otp_name_obj_path =
+ free_object_path(otp_client_s->otp_name_obj_path);
+ otp_client_s->otp_type_obj_path =
+ free_object_path(otp_client_s->otp_type_obj_path);
+ otp_client_s->otp_size_obj_path =
+ free_object_path(otp_client_s->otp_size_obj_path);
+ otp_client_s->otp_first_created_obj_path =
+ free_object_path(otp_client_s->otp_first_created_obj_path);
+ otp_client_s->otp_last_modified_obj_path =
+ free_object_path(otp_client_s->otp_last_modified_obj_path);
+ otp_client_s->otp_id_obj_path =
+ free_object_path(otp_client_s->otp_id_obj_path);
+ otp_client_s->otp_props_obj_path =
+ free_object_path(otp_client_s->otp_props_obj_path);
+
+ /* Reset CCCD */
+ otp_client_s->oacp_cccd_enabled = FALSE;
+ otp_client_s->olcp_cccd_enabled = FALSE;
+}
+
+int bt_otp_client_set_connection_state_changed_cb(bt_otp_client_h otp_client,
+ bt_otp_client_state_changed_cb callback, void *user_data)
+{
+ bt_otp_client_s *otp_client_s = (bt_otp_client_s *)otp_client;
+
+ BT_CHECK_LE_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(otp_client_s);
+ BT_CHECK_INPUT_PARAMETER(callback);
+
+ if (_bt_otp_client_find(otp_client_s->remote_address) == NULL)
+ return BT_ERROR_NOT_INITIALIZED;
+
+ BT_DBG("Set OTP Client Connection State changed callback");
+ /* register the callback */
+ otp_client_s->connection_callback = callback;
+ otp_client_s->conn_cb_user_data = user_data;
+
+ return BT_ERROR_NONE;
+}
+
+int bt_otp_client_unset_connection_state_changed_cb(bt_otp_client_h otp_client)
+{
+ bt_otp_client_s *otp_client_s = (bt_otp_client_s *)otp_client;
+
+ BT_CHECK_LE_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(otp_client_s);
+
+ if (_bt_otp_client_find(otp_client_s->remote_address) == NULL)
+ return BT_ERROR_NOT_INITIALIZED;
+
+ BT_DBG("UnSet OTP Client Connection State changed callback");
+ /* unregister the callback */
+ otp_client_s->connection_callback = NULL;
+ otp_client_s->conn_cb_user_data = NULL;
+
+ return BT_ERROR_NONE;
+}
+
+static int __bt_update_otp_server_data(bluetooth_device_address_t *address, bt_otp_client_s *otp_client_s)
+{
+ int ret = BLUETOOTH_ERROR_INTERNAL;
+ bt_gatt_service_property_t service;
+ int count;
+
+ ret = bluetooth_gatt_get_service_from_uuid(address, BT_OTP_SERVICE_UUID, &service);
+ if (ret != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Failed to find OTP service on the remote device [%s]", address);
+ return ret;
+ }
+
+ /* Discover all charc & desc of OTP service */
+ for (count = 0; count < service.char_handle.count; count++) {
+ bt_gatt_char_property_t characteristic;
+ memset(&characteristic, 0x00, sizeof(characteristic));
+
+ BT_DBG("Get properties for Char [%s]", service.char_handle.handle[count]);
+
+ ret = bluetooth_gatt_get_characteristics_property(service.char_handle.handle[count],
+ &characteristic);
+
+ if (ret != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Get characteristic property failed(0x%08x)", ret);
+ bluetooth_gatt_free_service_property(&service);
+ bluetooth_gatt_free_char_property(&characteristic);
+ goto fail;
+ } else {
+ if (g_strstr_len(characteristic.uuid, -1, BT_OTP_FEATURE_UUID)) {
+ BT_DBG("OTP feature characteristic discovered");
+
+ if (otp_client_s->otp_feature_obj_path)
+ g_free(otp_client_s->otp_feature_obj_path);
+ otp_client_s->otp_feature_obj_path = g_strdup(characteristic.handle);
+
+ ret = _bt_get_error_code(bluetooth_otp_read_characteristic_value(otp_client_s->otp_feature_obj_path));
+ if (ret != BT_ERROR_NONE)
+ BT_ERR("Failed to read OTP Feature : %s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+
+ BT_DBG("OTP feature handle [%s]", otp_client_s->otp_feature_obj_path);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OACP_CONTROL_POINT_UUID)) {
+ BT_DBG("OTP OACP Control Point discovered");
+ bt_gatt_char_descriptor_property_t desc_property;
+ memset(&desc_property, 0x00, sizeof(desc_property));
+
+ /* Get CCCD for Control Point */
+ ret = bluetooth_gatt_get_char_descriptor_property(
+ characteristic.char_desc_handle.handle[0], &desc_property);
+
+ if (ret != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Failed to discover CCCD for OACP Control point");
+ bluetooth_gatt_free_service_property(&service);
+ bluetooth_gatt_free_char_property(&characteristic);
+ bluetooth_gatt_free_desc_property(&desc_property);
+ goto fail;
+ }
+ if (otp_client_s->otp_oacp_control_point)
+ g_free(otp_client_s->otp_oacp_control_point);
+ otp_client_s->otp_oacp_control_point = g_strdup(characteristic.handle);
+
+ if (otp_client_s->otp_oacp_cccd)
+ g_free(otp_client_s->otp_oacp_cccd);
+ otp_client_s->otp_oacp_cccd = g_strdup(desc_property.handle);
+
+ BT_DBG("OACP Control point handle [%s]", otp_client_s->otp_oacp_control_point);
+ BT_DBG("OACP Control point CCCD handle [%s]", otp_client_s->otp_oacp_cccd);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OLCP_CONTROL_POINT_UUID)) {
+ BT_DBG("OTP OLCP Control Point discovered");
+ bt_gatt_char_descriptor_property_t desc_property;
+ memset(&desc_property, 0x00, sizeof(desc_property));
+
+ /* Get CCCD for Control Point */
+ ret = bluetooth_gatt_get_char_descriptor_property(
+ characteristic.char_desc_handle.handle[0], &desc_property);
+
+ if (ret != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Failed to discover CCCD for OLCP Control point");
+ bluetooth_gatt_free_service_property(&service);
+ bluetooth_gatt_free_char_property(&characteristic);
+ bluetooth_gatt_free_desc_property(&desc_property);
+ goto fail;
+ }
+ if (otp_client_s->otp_olcp_control_point)
+ g_free(otp_client_s->otp_olcp_control_point);
+ otp_client_s->otp_olcp_control_point = g_strdup(characteristic.handle);
+
+ if (otp_client_s->otp_olcp_cccd)
+ g_free(otp_client_s->otp_olcp_cccd);
+ otp_client_s->otp_olcp_cccd = g_strdup(desc_property.handle);
+
+ BT_DBG("OLCP Control point handle [%s]", otp_client_s->otp_olcp_control_point);
+ BT_DBG("OLCP Control point CCCD handle [%s]", otp_client_s->otp_olcp_cccd);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OBJECT_NAME_UUID)) {
+ BT_DBG("OTP Object Name characteristic discovered");
+
+ if (otp_client_s->otp_name_obj_path)
+ g_free(otp_client_s->otp_name_obj_path);
+ otp_client_s->otp_name_obj_path = g_strdup(characteristic.handle);
+
+ BT_DBG("OTP Object Name handle [%s]", otp_client_s->otp_name_obj_path);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OBJECT_TYPE_UUID)) {
+ BT_DBG("OTP Object Type characteristic discovered");
+
+ if (otp_client_s->otp_type_obj_path)
+ g_free(otp_client_s->otp_type_obj_path);
+ otp_client_s->otp_type_obj_path = g_strdup(characteristic.handle);
+
+ BT_DBG("OTP Object Type handle [%s]", otp_client_s->otp_type_obj_path);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OBJECT_SIZE_UUID)) {
+ BT_DBG("OTP Object Size characteristic discovered");
+
+ if (otp_client_s->otp_size_obj_path)
+ g_free(otp_client_s->otp_size_obj_path);
+ otp_client_s->otp_size_obj_path = g_strdup(characteristic.handle);
+
+ BT_DBG("OTP Object Size handle [%s]", otp_client_s->otp_size_obj_path);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OBJECT_FIRST_CREATED_UUID)) {
+ BT_DBG("OTP Object First Created characteristic discovered");
+
+ if (otp_client_s->otp_first_created_obj_path)
+ g_free(otp_client_s->otp_first_created_obj_path);
+ otp_client_s->otp_first_created_obj_path = g_strdup(characteristic.handle);
+
+ BT_DBG("OTP Object First Created handle [%s]", otp_client_s->otp_first_created_obj_path);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OBJECT_LAST_MODIFIED_UUID)) {
+ BT_DBG("OTP Object Last Modified characteristic discovered");
+
+ if (otp_client_s->otp_last_modified_obj_path)
+ g_free(otp_client_s->otp_last_modified_obj_path);
+ otp_client_s->otp_last_modified_obj_path = g_strdup(characteristic.handle);
+
+ BT_DBG("OTP Object Last Modified handle [%s]", otp_client_s->otp_last_modified_obj_path);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OBJECT_ID_UUID)) {
+ BT_DBG("OTP Object ID characteristic discovered");
+
+ if (otp_client_s->otp_id_obj_path)
+ g_free(otp_client_s->otp_id_obj_path);
+ otp_client_s->otp_id_obj_path = g_strdup(characteristic.handle);
+
+ BT_DBG("OTP Object ID handle [%s]", otp_client_s->otp_id_obj_path);
+ } else if (g_strstr_len(characteristic.uuid, -1, BT_OTP_OBJECT_PROP_UUID)) {
+ BT_DBG("OTP Object Properties characteristic discovered");
+
+ if (otp_client_s->otp_props_obj_path)
+ g_free(otp_client_s->otp_props_obj_path);
+ otp_client_s->otp_props_obj_path = g_strdup(characteristic.handle);
+
+ BT_DBG("OTP Object Properties handle [%s]", otp_client_s->otp_props_obj_path);
+ } else {
+ BT_DBG("Other OTP Characteristic handle [%s]", g_strdup(characteristic.handle));
+ BT_DBG("UUID [%s]", g_strdup(characteristic.uuid));
+ } /* Control Point characteristic */
+ } /* Characteristic property get successful */
+ bluetooth_gatt_free_char_property(&characteristic);
+ } /* Next Charatceristic */
+
+ if (otp_client_s->otp_service_handle)
+ g_free(otp_client_s->otp_service_handle);
+
+ otp_client_s->otp_service_handle = g_strdup(service.handle);
+ bluetooth_gatt_free_service_property(&service);
+ return ret;
+fail:
+ __bt_otp_client_reset_server_data(otp_client_s);
+ return ret;
+}
+
+void _bt_otp_client_connection_state_changed(int result,
+ const char *remote_address, bool connected)
+{
+ bt_otp_client_s *otp_client_s = NULL;
+ BT_DBG("OTP Client Connection state changed result [%d] connected [%d]", result, connected ? TRUE : FALSE);
+
+ otp_client_s = _bt_otp_client_find(remote_address);
+ if (otp_client_s) {
+ BT_DBG("OTP Client found against address [%s]", remote_address);
+
+ bluetooth_device_address_t addr_hex = { {0,} };
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ if (result != BT_ERROR_NONE) {
+ BT_ERR("GATT Connect Request failed Address [%s]", remote_address);
+ __bt_otp_client_reset_server_data(otp_client_s);
+
+ if (otp_client_s->connection_callback)
+ ((bt_otp_client_state_changed_cb)otp_client_s->connection_callback)
+ (result, remote_address, otp_client_s, connected, otp_client_s->conn_cb_user_data);
+ return;
+ }
+ /* Update OTP Service values */
+ if (connected) {
+ int error_code = BLUETOOTH_ERROR_NONE;
+ BT_DBG("Remote device connected successfully");
+ /* Attempt to update OTP Service data */
+ error_code = __bt_update_otp_server_data(&addr_hex, otp_client_s);
+ if (error_code != BLUETOOTH_ERROR_NONE)
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ } else {
+ BT_DBG("Remote device disconnected successfully");
+ /* Disconnected */
+ __bt_otp_client_reset_server_data(otp_client_s);
+ }
+ otp_client_s->connected = connected;
+
+ if (otp_client_s->connection_callback)
+ ((bt_otp_client_state_changed_cb)otp_client_s->connection_callback)
+ (result, remote_address, otp_client_s, connected, otp_client_s->conn_cb_user_data);
+ } else {
+ BT_DBG("OTP client not found!");
+ }
+}
+
+int bt_otp_client_create(const char *remote_address, bt_otp_client_h *otp_client)
+{
+ int error_code = BT_ERROR_NONE;
+ bt_otp_client_s *otp_client_s = NULL;
+ bool connected = false;
+ bluetooth_device_address_t addr_hex = { {0,} };
+ GSList *l;
+ BT_INFO("+");
+
+ BT_CHECK_LE_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+ BT_CHECK_INPUT_PARAMETER(otp_client);
+
+ for (l = otp_client_list; l; l = g_slist_next(l)) {
+ bt_otp_client_s *c = (bt_otp_client_s *)l->data;
+
+ if (!g_ascii_strcasecmp(c->remote_address, remote_address)) {
+ BT_ERR("OTP Client for Remote device [%s] is already created",
+ remote_address);
+ *otp_client = (bt_otp_client_h)c;
+ return BT_ERROR_ALREADY_DONE;
+ }
+ }
+
+ otp_client_s = g_malloc0(sizeof(*otp_client_s));
+ if (otp_client_s == NULL) {
+ error_code = BT_ERROR_OUT_OF_MEMORY;
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ return error_code;
+ }
+
+ if (bt_device_is_profile_connected(remote_address, BT_PROFILE_GATT,
+ &connected) != BT_ERROR_NONE)
+ BT_ERR("bt_device_is_profile_connected is failed");
+ otp_client_s->connected = connected;
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ if (otp_client_s->connected == true) {
+ /* Update all serv & charc */
+ error_code = __bt_update_otp_server_data(&addr_hex, otp_client_s);
+ if (error_code != BLUETOOTH_ERROR_NONE) {
+ g_free(otp_client_s);
+ return BT_ERROR_OPERATION_FAILED;
+ }
+ }
+
+ otp_client_s->remote_address = g_strdup(remote_address);
+ if (otp_client_s->remote_address == NULL) {
+ free(otp_client_s);
+ error_code = BT_ERROR_OUT_OF_MEMORY;
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ return error_code;
+ }
+
+ otp_client_s->olcp_cccd_enabled = FALSE;
+ otp_client_s->oacp_cccd_enabled = FALSE;
+
+ otp_client_list = g_slist_append(otp_client_list, otp_client_s);
+ *otp_client = (bt_otp_client_h)otp_client_s;
+
+ BT_DBG("OTP Client Created");
+ return BT_ERROR_NONE;
+}
+
+int bt_otp_client_destroy(bt_otp_client_h otp_client)
+{
+ bt_otp_client_s *otp_client_s = (bt_otp_client_s *)otp_client;
+
+ BT_CHECK_LE_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(otp_client_s);
+
+ if (_bt_otp_client_find(otp_client_s->remote_address) == NULL)
+ return BT_ERROR_NOT_INITIALIZED;
+
+ BT_DBG("OTP client Remote device [%s]", otp_client_s->remote_address);
+ __bt_otp_client_reset_server_data(otp_client_s);
+
+ otp_client_list = g_slist_remove(otp_client_list, otp_client_s);
+ g_free(otp_client_s);
+ otp_client_s = NULL;
+
+ return BT_ERROR_NONE;
+}
+
+int bt_otp_client_connect(bt_otp_client_h otp_client)
+{
+ int error_code;
+ bt_otp_client_s *otp_client_s = (bt_otp_client_s *)otp_client;
+
+ BT_CHECK_LE_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(otp_client_s);
+
+ if (_bt_otp_client_find(otp_client_s->remote_address) == NULL)
+ return BT_ERROR_NOT_INITIALIZED;
+
+ if (otp_client_s->connected)
+ return BT_ERROR_NONE;
+
+ BT_DBG("OTP client connect Remote device [%s]", otp_client_s->remote_address);
+ error_code = bt_gatt_connect(otp_client_s->remote_address, FALSE);
+
+ 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_otp_client_disconnect(bt_otp_client_h otp_client)
+{
+ int error_code;
+ bt_otp_client_s *otp_client_s = (bt_otp_client_s *)otp_client;
+
+ BT_CHECK_LE_SUPPORT();
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(otp_client_s);
+
+ if (_bt_otp_client_find(otp_client_s->remote_address) == NULL)
+ return BT_ERROR_NOT_INITIALIZED;
+
+ if (otp_client_s->connected == false) {
+ BT_ERR("Remote device [%s] is not conencted", otp_client_s->remote_address);
+ return BT_ERROR_OPERATION_FAILED;
+ }
+
+ BT_DBG("OTP client Disconnect Remote device [%s]", otp_client_s->remote_address);
+ error_code = bt_gatt_disconnect(otp_client_s->remote_address);
+
+ if (error_code != BT_ERROR_NONE)
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+
+ return error_code;
+}
+
+void _bt_otp_get_remote_address(char *handle, char *remote_address)
+{
+ char *dev_path;
+ dev_path = strstr(handle, "dev_");
+ dev_path += 4;
+ /* 18 -> Length of BT ADDR in path */
+ g_strlcpy(remote_address, dev_path, BT_ADDR_LENGTH);
+ g_strdelimit(remote_address, "_", ':');
+ BT_INFO("[%s] --> [%s]", handle, remote_address);
+}
+
+void _bt_otp_client_read_value_response(int result, char *char_path,
+ char *value, int len)
+{
+ bt_otp_client_s *otp_client_s = NULL;
+ char remote_address[BT_ADDR_LENGTH];
+
+ _bt_otp_get_remote_address(char_path, remote_address);
+
+ BT_DBG("OTP client Read Value Response [%d] [%s] [%s] [%d]", result,
+ char_path, value, len);
+ if (result != BLUETOOTH_ERROR_NONE)
+ BT_INFO("Read failed for [%s]", char_path);
+
+ otp_client_s = _bt_otp_client_find(remote_address);
+ if (otp_client_s == NULL)
+ return;
+
+ if (!g_strcmp0(otp_client_s->otp_feature_obj_path, char_path)) {
+ int error_code;
+ uint64_t feature = (uint64_t)(value[0] & 0xFF) << 56 |
+ (uint64_t)(value[1] & 0xFF) << 48 |
+ (uint64_t)(value[2] & 0xFF) << 40 |
+ (uint64_t)(value[3] & 0xFF) << 32 |
+ (uint64_t)(value[4] & 0xFF) << 24 |
+ (uint64_t)(value[5] & 0xFF) << 16 |
+ (uint64_t)(value[6] & 0xFF) << 8 |
+ (uint64_t)(value[7] & 0xFF);
+ otp_client_s->otp_feature = feature;
+ BT_INFO("OTP Feature [%lld]", feature);
+
+ if (IS_OACP_SUPPORTED(otp_client_s->otp_feature)
+ && !otp_client_s->oacp_cccd_enabled) {
+
+ error_code = bluetooth_otp_enable_notification(otp_client_s->otp_oacp_control_point);
+ if (error_code != BT_ERROR_NONE)
+ BT_ERR("OACP Notification enable failed %s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ if (IS_OLCP_SUPPORTED(otp_client_s->otp_feature)
+ && !otp_client_s->olcp_cccd_enabled) {
+ error_code = bluetooth_otp_enable_notification(otp_client_s->otp_olcp_control_point);
+ if (error_code != BT_ERROR_NONE)
+ BT_ERR("OLCP Notification enable failed %s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ }
+ } else {
+ /* Handle other Object Metadata read response */
+ }
+}
+
+void _bt_otp_client_notification_enabled(int result, char *handle)
+{
+ bt_otp_client_s *otp_client_s = NULL;
+ char remote_address[BT_ADDR_LENGTH];
+ BT_DBG("OTP notificaton [%d] [%s]", result, handle);
+ _bt_otp_get_remote_address(handle, remote_address);
+
+ otp_client_s = _bt_otp_client_find(remote_address);
+ if (otp_client_s == NULL)
+ return;
+
+ if (!g_strcmp0(otp_client_s->otp_oacp_control_point, handle)) {
+ if (result != BLUETOOTH_ERROR_NONE) {
+ otp_client_s->oacp_cccd_enabled = FALSE;
+ BT_ERR("Failed to enable OACP notification : %s(0x%08x)", _bt_convert_error_to_string(result), result);
+ } else {
+ otp_client_s->oacp_cccd_enabled = TRUE;
+ }
+ } else if (!g_strcmp0(otp_client_s->otp_olcp_control_point, handle)) {
+ if (result != BLUETOOTH_ERROR_NONE) {
+ otp_client_s->olcp_cccd_enabled = FALSE;
+ BT_ERR("Failed to enable OLCP notification : %s(0x%08x)", _bt_convert_error_to_string(result), result);
+ } else {
+ otp_client_s->olcp_cccd_enabled = TRUE;
+ }
+ }
+}
projects / platform / core / api / bluetooth.git / commitdiff