From: Atul Rai Date: Thu, 30 Jun 2016 08:12:05 +0000 (+0900) Subject: [Adapt: bluez_hal]Implement get_adapter_property X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=236fc7c3d3316a0d04339590f61bec753e061c5e;p=platform%2Fcore%2Fconnectivity%2Fbluetooth-frwk.git [Adapt: bluez_hal]Implement get_adapter_property This patch adds implementation for HAL API get_adapter_property(bt_property_type_t type) This API is used to retrieve local adapter property specified by the input parameter type. Change-Id: I7c7c78093d87206b67b3a17003a2df342d6801bc Signed-off-by: Atul Rai --- diff --git a/bt-oal/bluez_hal/src/bt-hal-adapter-dbus-handler.c b/bt-oal/bluez_hal/src/bt-hal-adapter-dbus-handler.c index fa05175..6e6c0e6 100644 --- a/bt-oal/bluez_hal/src/bt-hal-adapter-dbus-handler.c +++ b/bt-oal/bluez_hal/src/bt-hal-adapter-dbus-handler.c @@ -464,3 +464,506 @@ int _bt_hal_dbus_get_adapter_properties(void) DBG("-"); } + +/* Get Discoverable timeout API and callback */ +static gboolean __bt_adapter_discovery_timeout_cb(gpointer user_data) +{ + /* Buffer and propety count management */ + uint8_t buf[BT_MAX_PROPERTY_BUF_SIZE]; + struct hal_ev_adapter_props_changed *ev = (void*) buf;; + size_t size = 0; + unsigned int *timeout = user_data; + + memset(buf, 0, sizeof(buf)); + size = sizeof(*ev); + ev->num_props = 0; + ev->status = BT_STATUS_SUCCESS; + + DBG("Discovery timeout in callback: [%d]", *timeout); + + size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_DISC_TIMEOUT, + sizeof(unsigned int), timeout); + + ev->num_props++; + DBG("Timeout value [%d] property Num [%d]", *timeout, ev->num_props); + + if (size > 2) { + DBG("Send Adapter Properties changed event to HAL user," + " Num Prop [%d] total size [%d]",ev->num_props, size); + event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size); + } + + g_free(timeout); + return FALSE; +} + +int _bt_hal_dbus_get_discovery_timeout(void) +{ + GDBusProxy *proxy; + GVariant *result; + GVariant *temp; + GError *error = NULL; + unsigned int *timeout; + DBG("+"); + + proxy = _bt_get_adapter_properties_proxy(); + if (!proxy) { + DBG("Adapter Properties proxy get failed!!!"); + return BT_STATUS_FAIL; + } + + result = g_dbus_proxy_call_sync(proxy, + "Get", + g_variant_new("(ss)", BT_ADAPTER_INTERFACE, + "DiscoverableTimeout"), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + + if (!result) { + if (error != NULL) { + ERR("Failed to get local version (Error: %s)", error->message); + g_clear_error(&error); + } else + ERR("Failed to get local version"); + return BT_STATUS_FAIL; + } + + timeout = g_malloc0(sizeof(int)); + if (!timeout) { + ERR("Memory allocation failed"); + g_variant_unref(result); + return BT_STATUS_FAIL; + } + + g_variant_get(result, "(v)", &temp); + *timeout = g_variant_get_uint32(temp); + DBG("Timeout value: [%d]", *timeout); + + g_variant_unref(result); + g_variant_unref(temp); + + /* + * As we need to provide async callback to user from HAL, simply schedule a + * callback method which will carry actual result + */ + g_idle_add(__bt_adapter_discovery_timeout_cb, (gpointer) timeout); + + DBG("-"); + return BT_STATUS_SUCCESS; +} + +/* Get Discoverable Mode API and callback */ +static gboolean __bt_adapter_scan_mode_cb(gpointer user_data) +{ + /* Buffer and propety count management */ + uint8_t buf[BT_MAX_PROPERTY_BUF_SIZE]; + struct hal_ev_adapter_props_changed *ev = (void*) buf;; + size_t size = 0; + int *mode = user_data; + + memset(buf, 0, sizeof(buf)); + size = sizeof(*ev); + ev->num_props = 0; + ev->status = BT_STATUS_SUCCESS; + + DBG("Scan mode callback: [%d]", *mode); + + size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_SCAN_MODE, + sizeof(int), mode); + + ev->num_props++; + DBG("Scan mode [%d] property Num [%d]", *mode, ev->num_props); + + if (size > 2) { + DBG("Send Adapter Properties changed event to HAL user," + " Num Prop [%d] total size [%d]",ev->num_props, size); + event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size); + } + + g_free(mode); + return FALSE; +} + +int _bt_hal_dbus_get_scan_mode(void) +{ + GDBusProxy *proxy; + gboolean discoverable; + gboolean connectable; + GVariant *result; + GVariant *temp; + GError *error = NULL; + int *scan_mode; + ; + DBG("+"); + + proxy = _bt_get_adapter_properties_proxy(); + if (!proxy) { + DBG("Adapter Properties proxy get failed!!!"); + return BT_STATUS_FAIL; + } + + result = g_dbus_proxy_call_sync(proxy, + "Get", + g_variant_new("(ss)", BT_ADAPTER_INTERFACE, + "Discoverable"), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + + if (!result) { + if (error != NULL) { + ERR("Failed to get discoverable mode (Error: %s)", error->message); + g_clear_error(&error); + } else + ERR("Failed to get discoverable mode"); + return BT_STATUS_FAIL; + } + + g_variant_get(result, "(v)", &temp); + discoverable = g_variant_get_boolean(temp); + DBG("discoverable:%d", discoverable); + + g_variant_unref(result); + g_variant_unref(temp); + + if (!discoverable) { + result = g_dbus_proxy_call_sync(proxy, + "Get", + g_variant_new("(ss)", BT_ADAPTER_INTERFACE, + "Connectable"), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + if (!result) { + if (error != NULL) { + ERR("Failed to get connectable mode (Error: %s)", error->message); + g_clear_error(&error); + } else + ERR("Failed to get connectable mode"); + return BT_STATUS_FAIL; + } + + g_variant_get(result, "(v)", &temp); + connectable = g_variant_get_boolean(temp); + DBG("connectable:%d", connectable); + + g_variant_unref(result); + g_variant_unref(temp); + } + + scan_mode = g_malloc0(sizeof(int)); + if (!scan_mode) { + ERR("Memory allocation failed"); + return BT_STATUS_FAIL; + } + + if (discoverable) + *scan_mode = BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE; + else if (connectable) + *scan_mode = BT_SCAN_MODE_CONNECTABLE; + else + *scan_mode = BT_SCAN_MODE_NONE; + + /* + * As we need to provide async callback to user from HAL, simply schedule a + * callback method which will carry actual result + */ + g_idle_add(__bt_adapter_scan_mode_cb, (gpointer) scan_mode); + + DBG("-"); + return BT_STATUS_SUCCESS; +} + +/* Get Local Version API and callback */ +static gboolean __bt_adapter_local_version_cb(gpointer user_data) +{ + /* Buffer and propety count management */ + uint8_t buf[BT_MAX_PROPERTY_BUF_SIZE]; + struct hal_ev_adapter_props_changed *ev = (void*) buf;; + size_t size = 0; + char *version = NULL; + + memset(buf, 0, sizeof(buf)); + size = sizeof(*ev); + ev->num_props = 0; + ev->status = BT_STATUS_SUCCESS; + + version = (char*) user_data; + DBG("Local Version in callback: [%s]", version); + + size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_VERSION, + (strlen(version) + 1), version); + + ev->num_props++; + DBG("Device version [%s] property Num [%d]", version, ev->num_props); + + if (size > 2) { + DBG("Send Adapter Properties changed event to HAL user," + " Num Prop [%d] total size [%d]",ev->num_props, size); + event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size); + } + + g_free(version); + return FALSE; +} + +int _bt_hal_dbus_get_local_version(void) +{ + GDBusProxy *proxy; + const char *version = NULL; + GVariant *result; + GVariant *temp; + GError *error = NULL; + DBG("+"); + + proxy = _bt_get_adapter_properties_proxy(); + if (!proxy) { + DBG("Adapter Properties proxy get failed!!!"); + return BT_STATUS_FAIL; + } + + result = g_dbus_proxy_call_sync(proxy, + "Get", + g_variant_new("(ss)", BT_ADAPTER_INTERFACE, + "Version"), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + + if (!result) { + if (error != NULL) { + ERR("Failed to get local version (Error: %s)", error->message); + g_clear_error(&error); + } else + ERR("Failed to get local version"); + return BT_STATUS_FAIL; + } + + g_variant_get(result, "(v)", &temp); + version = g_variant_dup_string(temp, NULL); + DBG("Local Version: [%s]", version); + + g_variant_unref(result); + g_variant_unref(temp); + + /* + * As we need to provide async callback to user from HAL, simply schedule a + * callback method which will carry actual result + */ + g_idle_add(__bt_adapter_local_version_cb, (gpointer) version); + + DBG("-"); + return BT_STATUS_SUCCESS; +} + +/* Get Local Name API and callback */ +static gboolean __bt_adapter_local_name_cb(gpointer user_data) +{ + /* Buffer and propety count management */ + uint8_t buf[BT_MAX_PROPERTY_BUF_SIZE]; + struct hal_ev_adapter_props_changed *ev = (void*) buf;; + size_t size = 0; + char *name = NULL; + + memset(buf, 0, sizeof(buf)); + size = sizeof(*ev); + ev->num_props = 0; + ev->status = BT_STATUS_SUCCESS; + + name = (char*) user_data; + DBG("Local Name in callback: [%s]", name); + + size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_NAME, + strlen(name) + 1, name); + + ev->num_props++; + DBG("Device name [%s] property Num [%d]",name, ev->num_props); + + if (size > 2) { + DBG("Send Adapter Properties changed event to HAL user," + " Num Prop [%d] total size [%d]",ev->num_props, size); + event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size); + } + + g_free(name); + return FALSE; +} + +int _bt_hal_dbus_get_local_name(void) +{ + GDBusProxy *proxy; + const char *name = NULL; + GVariant *result; + GVariant *temp; + GError *error = NULL; + DBG("+"); + + proxy = _bt_get_adapter_properties_proxy(); + if (!proxy) { + DBG("_bt_hal_dbus_get_local_name: Adapter Properties proxy get failed!!!"); + return BT_STATUS_FAIL; + } + + result = g_dbus_proxy_call_sync(proxy, + "Get", + g_variant_new("(ss)", BT_ADAPTER_INTERFACE, + "Alias"), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + + if (!result) { + if (error != NULL) { + ERR("Failed to get local name (Error: %s)", error->message); + g_clear_error(&error); + } else + ERR("Failed to get local name"); + return BT_STATUS_FAIL; + } + + g_variant_get(result, "(v)", &temp); + name = g_variant_dup_string(temp, NULL); + DBG("Local Name: [%s]", name); + + g_variant_unref(result); + g_variant_unref(temp); + + /* + * As we need to provide async callback to user from HAL, simply schedule a + * callback method which will carry actual result + */ + g_idle_add(__bt_adapter_local_name_cb, (gpointer) name); + + DBG("-"); + return BT_STATUS_SUCCESS; +} + +/* Get Local Address API and callback */ +static gboolean __bt_adapter_local_address_cb(gpointer user_data) +{ + /* Buffer and propety count management */ + uint8_t buf[BT_MAX_PROPERTY_BUF_SIZE]; + struct hal_ev_adapter_props_changed *ev = (void*) buf; + size_t size = 0; + char * address = NULL; + + memset(buf, 0, sizeof(buf)); + size = sizeof(*ev); + ev->num_props = 0; + ev->status = BT_STATUS_SUCCESS; + + address = (char*) user_data; + + uint8_t bdaddr[6]; + _bt_convert_addr_string_to_type(bdaddr, address); + + size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR, + sizeof(bdaddr), bdaddr); + + ev->num_props++; + DBG("Device address [%s] property Num [%d]",address, ev->num_props); + + size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_ADDR, + sizeof(bdaddr), bdaddr); + + if (size > 1) { + DBG("Send Device found event to HAL user," + " Num Prop [%d] total size [%d]",ev->num_props, size); + event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size); + } + + g_free(address); + return FALSE; +} + +int _bt_hal_dbus_get_local_address(void) +{ + GDBusProxy *proxy; + GError *error = NULL; + const char *address; + GVariant *result; + GVariant *temp; + + DBG("+"); + + proxy = _bt_get_adapter_properties_proxy(); + if (!proxy) { + DBG("_bt_hal_dbus_get_local_address: Adapter Properties proxy get failed!!!"); + return BT_STATUS_FAIL; + } + + result = g_dbus_proxy_call_sync(proxy, + "Get", + g_variant_new("(ss)", BT_ADAPTER_INTERFACE, + "Address"), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + + if (!result) { + ERR("Failed to get local address"); + if (error != NULL) { + ERR("Failed to get local address (Error: %s)", error->message); + g_clear_error(&error); + } + return BT_STATUS_FAIL; + } + + g_variant_get(result, "(v)", &temp); + address = g_variant_dup_string(temp, NULL); + + if (address) { + DBG("Address:%s", address); + } else { + return BT_STATUS_FAIL; + } + + g_variant_unref(result); + g_variant_unref(temp); + + /* + * As we need to provide async callback to user from HAL, simply schedule a + * callback method which will carry actual result + */ + g_idle_add(__bt_adapter_local_address_cb, (gpointer) address); + + DBG("-"); + return BT_STATUS_SUCCESS; +} + +int _bt_hal_dbus_get_adapter_property(bt_property_type_t property_type) +{ + DBG("+"); + + INFO("property_type: %d", property_type); + + switch (property_type) { + case BT_PROPERTY_BDADDR: + return _bt_hal_dbus_get_local_address(); + case BT_PROPERTY_BDNAME: + return _bt_hal_dbus_get_local_name(); + case BT_PROPERTY_VERSION: + return _bt_hal_dbus_get_local_version(); + case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT: + return _bt_hal_dbus_get_discovery_timeout(); + case BT_PROPERTY_ADAPTER_SCAN_MODE: + return _bt_hal_dbus_get_scan_mode(); + case BT_PROPERTY_CLASS_OF_DEVICE: + return BT_STATUS_UNSUPPORTED; + case BT_PROPERTY_UUIDS: + return BT_STATUS_UNSUPPORTED; + case BT_PROPERTY_ADAPTER_BONDED_DEVICES: + return BT_STATUS_UNSUPPORTED; + default: + return BT_STATUS_UNSUPPORTED; + } + + DBG("-"); +} diff --git a/bt-oal/bluez_hal/src/bt-hal-adapter-dbus-handler.h b/bt-oal/bluez_hal/src/bt-hal-adapter-dbus-handler.h index e68d6b1..29553be 100644 --- a/bt-oal/bluez_hal/src/bt-hal-adapter-dbus-handler.h +++ b/bt-oal/bluez_hal/src/bt-hal-adapter-dbus-handler.h @@ -42,6 +42,8 @@ int _bt_hal_dbus_enable_adapter(void); int _bt_hal_dbus_disable_adapter(void); +int _bt_hal_dbus_get_adapter_property(bt_property_type_t type); + int _bt_hal_dbus_get_adapter_properties(void); #ifdef __cplusplus diff --git a/bt-oal/bluez_hal/src/bt-hal-bluetooth.c b/bt-oal/bluez_hal/src/bt-hal-bluetooth.c index e5b9317..da7a76d 100644 --- a/bt-oal/bluez_hal/src/bt-hal-bluetooth.c +++ b/bt-oal/bluez_hal/src/bt-hal-bluetooth.c @@ -99,7 +99,7 @@ static int get_adapter_properties(void) static int get_adapter_property(bt_property_type_t type) { - return BT_STATUS_UNSUPPORTED; + return _bt_hal_dbus_get_adapter_property(type); } static int set_adapter_property(const bt_property_t *property)