[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 <a.rai@samsung.com>

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 (file)
--- 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 (file)
--- 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 (file)
--- 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)