#include <string.h>
#include <vconf.h>
#include <syspopup_caller.h>
-#include <aul.h>
-#include <dbus/dbus-glib.h>
-#include <dbus/dbus.h>
#include <bundle.h>
#include <eventsystem.h>
#include <bundle_internal.h>
#include "bt-service-network.h"
#include "bt-service-obex-server.h"
#include "bt-service-opp-client.h"
+#include "bt-service-map-client.h"
#include "bt-service-agent.h"
#include "bt-service-main.h"
#include "bt-service-avrcp.h"
#include "bt-service-device.h"
-#ifdef TIZEN_DPM_ENABLE
+#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-service-dpm.h"
#endif
static bt_service_alarm_mgr_t alarm_mgr = {0, };
static gboolean is_discovering;
+static gboolean discovery_req;
static gboolean cancel_by_user;
static bt_status_t adapter_status = BT_DEACTIVATED;
static bt_le_status_t adapter_le_status = BT_LE_DEACTIVATED;
GDBusProxy *proxy;
GDBusConnection *conn;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (!conn)
return NULL;
static GDBusProxy *__bt_get_core_proxy(void)
{
- return (core_proxy) ? core_proxy : _bt_init_core_proxy();
+ return (core_proxy) ? core_proxy : _bt_init_core_proxy();
}
static gboolean __bt_is_factory_test_mode(void)
visible_timer.event_id = 0;
visible_timer.timeout = 0;
-#ifndef TIZEN_PROFILE_WEARABLE
- if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
- BT_ERR("Set vconf failed\n");
-#endif
+ if (!TIZEN_PROFILE_WEARABLE) {
+ if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
+ BT_ERR("Set vconf failed\n");
+ }
return FALSE;
}
visible_timer.event_id = 0;
visible_timer.timeout = 0;
-#ifndef TIZEN_PROFILE_WEARABLE
- if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
- BT_ERR("Set vconf failed\n");
-#endif
+ if (!TIZEN_PROFILE_WEARABLE) {
+ if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
+ BT_ERR("Set vconf failed\n");
+ }
}
/* Switch Off visibility in Bluez */
_bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0);
{
int result;
alarm_id_t alarm_id;
+#ifdef TIZEN_FEATURE_BT_DPM
+ int discoverable_state = DPM_BT_ERROR;
+#endif
__bt_visibility_alarm_remove();
visible_timer.timeout = timeout;
-#ifndef TIZEN_PROFILE_WEARABLE
-#ifdef TIZEN_DPM_ENABLE
- if (_bt_dpm_get_bluetooth_limited_discoverable_state() != DPM_RESTRICTED) {
-#endif
- if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
- BT_ERR("Set vconf failed");
-#ifdef TIZEN_DPM_ENABLE
- }
+ if (!TIZEN_PROFILE_WEARABLE) {
+#ifdef TIZEN_FEATURE_BT_DPM
+ _bt_dpm_get_bluetooth_limited_discoverable_state(&discoverable_state);
+ if (discoverable_state != DPM_RESTRICTED) {
#endif
+ if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
+ BT_ERR("Set vconf failed");
+#ifdef TIZEN_FEATURE_BT_DPM
+ }
#endif
+ }
if (timeout <= 0)
BT_CHECK_PARAMETER(device_path, return);
BT_CHECK_PARAMETER(dev_info, return);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
} else if (!g_strcmp0(key, "Name")) {
if (!name)
g_variant_get(value, "s", &name);
- } else if(!g_strcmp0(key, "IsAliasSet")) {
- dev_info->is_alias_set = g_variant_get_boolean(value);
} else if (!g_strcmp0(key, "Class")) {
cod = g_variant_get_uint32(value);
} else if (!g_strcmp0(key, "Connected")) {
} else if (!g_strcmp0(key, "ManufacturerData")) {
manufacturer_data = g_byte_array_new();
g_variant_get(value, "ay", &char_value_iter);
- while (g_variant_iter_loop(char_value_iter, "y", &char_value)) {
+ while (g_variant_iter_loop(char_value_iter, "y", &char_value))
g_byte_array_append(manufacturer_data, &char_value, 1);
- }
+
g_variant_iter_free(char_value_iter);
if (manufacturer_data) {
void _bt_set_discovery_status(gboolean mode)
{
is_discovering = mode;
+ discovery_req = FALSE;
}
void _bt_set_cancel_by_user(gboolean value)
phone_name = vconf_keynode_get_str(node);
if (phone_name && strlen(phone_name) != 0) {
- if (!g_utf8_validate(phone_name, -1,
+ if (!g_utf8_validate(phone_name, -1,
(const char **)&ptr))
- *ptr = '\0';
+ *ptr = '\0';
_bt_set_local_name(phone_name);
}
return BLUETOOTH_ERROR_INTERNAL;
}
-#ifdef TIZEN_PROFILE_MOBILE
- /* BT setting UI will control Mobile's visible mode. So in the FRWK...set the visible mode as off: */
- if (_bt_set_discoverable_mode(
- BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0) != BLUETOOTH_ERROR_NONE)
- BT_ERR("Set connectable mode failed");
-#else
-#ifdef TIZEN_TV
- if (_bt_set_discoverable_mode(
- BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE, 0) != BLUETOOTH_ERROR_NONE)
- BT_ERR("Fail to set discoverable mode");
-#endif
-#endif
+ if (TIZEN_PROFILE_MOBILE || TIZEN_PROFILE_IVI) {
+ /* BT setting UI will control Mobile's visible mode. So in the FRWK...set the visible mode as off: */
+ if (_bt_set_discoverable_mode(
+ BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0) != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Set connectable mode failed");
+ } else if (TIZEN_PROFILE_TV) {
+ if (_bt_set_discoverable_mode(
+ BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE, 0) != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Fail to set discoverable mode");
+ }
/* Update Bluetooth Status to notify other modules */
if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_ON) != 0)
_bt_adapter_set_status(BT_DEACTIVATED);
_bt_set_discovery_status(FALSE);
-#ifndef USB_BLUETOOTH
- if (_bt_adapter_get_le_status() != BT_LE_DEACTIVATED) {
-#endif
+ if (TIZEN_FEATURE_BT_USB_DONGLE ||
+ _bt_adapter_get_le_status() != BT_LE_DEACTIVATED) {
/* Send disabled event */
_bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
g_variant_new("(i)", result));
-#ifndef USB_BLUETOOTH
}
-#endif
BT_INFO("Adapter disabled");
}
/* Send disabled event */
_bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_DISABLED,
- g_variant_new_int32(result));
+ g_variant_new("(i)", result));
}
void *_bt_get_adapter_agent(void)
return BLUETOOTH_ERROR_NONE;
}
-#if defined(TIZEN_FEATURE_FLIGHTMODE_ENABLED) || (!defined(TIZEN_PROFILE_WEARABLE))
static void __bt_service_flight_ps_mode_cb(keynode_t *node, void *data)
{
gboolean flight_mode = FALSE;
_bt_enable_core();
}
-#endif
void _bt_service_register_vconf_handler(void)
{
BT_DBG("+");
-#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
- if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
- (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
- BT_ERR("Unable to register key handler");
-#else
- BT_DBG("Telephony is disabled");
-#endif
+ if (TIZEN_FEATURE_FLIGHTMODE_ENABLED) {
+ if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
+ (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
+ BT_ERR("Unable to register key handler");
+ } else {
+ BT_DBG("Telephony is disabled");
+ }
-#ifndef TIZEN_PROFILE_WEARABLE
- if (vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
- (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
- BT_ERR("Unable to register key handler");
-#endif
+ if (!TIZEN_PROFILE_WEARABLE) {
+ if (vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
+ (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
+ BT_ERR("Unable to register key handler");
+ }
}
void _bt_service_unregister_vconf_handler(void)
{
BT_DBG("+");
-#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
- vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
- (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
-#endif
+ if (TIZEN_FEATURE_FLIGHTMODE_ENABLED) {
+ vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
+ (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
+ }
-#ifndef TIZEN_PROFILE_WEARABLE
- vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
- (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
-#endif
+ if (!TIZEN_PROFILE_WEARABLE) {
+ vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
+ (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
+ }
}
static void __bt_state_event_handler(const char *event_name, bundle *data, void *user_data)
BT_DBG("status : %d", status);
BT_DBG("le_status : %d", le_status);
-#ifndef USB_BLUETOOTH
- adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
- if (!adapter_agent) {
- BT_ERR("Fail to register agent");
- return;
- }
-#else
- if (adapter_agent == NULL) {
+ if (!TIZEN_FEATURE_BT_USB_DONGLE) {
adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
if (!adapter_agent) {
BT_ERR("Fail to register agent");
return;
}
+ } else {
+ if (adapter_agent == NULL) {
+ adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
+ if (!adapter_agent) {
+ BT_ERR("Fail to register agent");
+ return;
+ }
+ }
}
-#endif
if (_bt_register_media_player() != BLUETOOTH_ERROR_NONE)
BT_ERR("Fail to register media player");
_bt_adapter_set_status(BT_ACTIVATED);
}
- _bt_service_register_vconf_handler();
-
/* eventsystem */
if (eventsystem_register_event(SYS_EVENT_BT_STATE, &status_reg_id,
(eventsystem_handler)__bt_state_event_handler, NULL) != ES_R_OK) {
ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
(vconf_callback_fn)__bt_phone_name_changed_cb);
- if (0 != ret) {
+ if (0 != ret)
ERR("vconf_ignore_key_changed failed\n");
- }
-#ifndef USB_BLUETOOTH
- _bt_destroy_agent(adapter_agent);
- adapter_agent = NULL;
+/* unregister all the services/servers/profiles registered on bluez-adapter
+ once adapter is removed, reinitializing of the state-varaibles becomes
+ a problem */
+ if (_bt_unregister_obex_server() != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Fail to unregister obex server");
- if (is_recovery_mode == TRUE) {
- /* Send disabled event */
- _bt_set_disabled(BLUETOOTH_ERROR_NONE);
+ if (_bt_unregister_media_player() != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Fail to unregister media player");
- /* Will recover BT by bt-core, so set the mode as activating */
- _bt_adapter_set_status(BT_ACTIVATING);
- is_recovery_mode = FALSE;
+/* Other unregister APIs should be placed here */
+
+ if (!TIZEN_FEATURE_BT_USB_DONGLE) {
+ _bt_destroy_agent(adapter_agent);
+ adapter_agent = NULL;
+
+ if (is_recovery_mode == TRUE) {
+ /* Send disabled event */
+ _bt_set_disabled(BLUETOOTH_ERROR_NONE);
+
+ /* Will recover BT by bt-core, so set the mode as activating */
+ _bt_adapter_set_status(BT_ACTIVATING);
+ is_recovery_mode = FALSE;
+ } else {
+ _bt_reliable_terminate_service(NULL);
+ }
} else {
- _bt_reliable_terminate_service(NULL);
+ _bt_set_disabled(BLUETOOTH_ERROR_NONE);
}
-#else
- _bt_set_disabled(BLUETOOTH_ERROR_NONE);
-#endif
if (eventsystem_unregister_event(status_reg_id) != ES_R_OK)
BT_ERR("Fail to unregister system event");
g_variant_unref(result);
_bt_set_disabled(BLUETOOTH_ERROR_TIMEOUT);
-#ifndef USB_BLUETOOTH
- _bt_terminate_service(NULL);
-#endif
+ if (!TIZEN_FEATURE_BT_USB_DONGLE)
+ _bt_terminate_service(NULL);
return FALSE;
}
return;
}
-#ifdef TIZEN_TV
static gboolean __bt_adapter_enabled_cb(gpointer user_data)
{
BT_DBG("+");
return FALSE;
}
-#endif
+
+int _bt_enable_adapter_check_status(void)
+{
+ bt_status_t status = _bt_adapter_get_status();
+ bt_le_status_t le_status = _bt_adapter_get_le_status();
+
+ BT_DBG("");
+
+ if (status == BT_ACTIVATING) {
+ BT_ERR("Enabling in progress");
+ return BLUETOOTH_ERROR_IN_PROGRESS;
+ }
+
+ if (status == BT_ACTIVATED) {
+ BT_ERR("Already enabled");
+ return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
+ }
+
+ if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
+ BT_ERR("Disabling in progress");
+ return BLUETOOTH_ERROR_DEVICE_BUSY;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
int _bt_enable_adapter(void)
{
_bt_adapter_set_status(BT_ACTIVATING);
-#ifdef TIZEN_TV
-{
+if (TIZEN_PROFILE_TV) {
int adapter_status = BT_ADAPTER_DISABLED;
if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
return BLUETOOTH_ERROR_NONE;
}
}
-#endif
proxy = __bt_get_core_proxy();
if (!proxy)
if (le_status == BT_LE_ACTIVATED) {
BT_INFO("LE Already enabled. Just turn on PSCAN");
ret = _bt_set_connectable(TRUE);
- if (ret == BLUETOOTH_ERROR_NONE) {
+ if (ret == BLUETOOTH_ERROR_NONE)
_bt_adapter_set_status(BT_ACTIVATED);
- } else {
+ else
return BLUETOOTH_ERROR_INTERNAL;
- }
}
result = g_dbus_proxy_call_sync(proxy, "EnableAdapter",
G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
NULL, &error);
if (error) {
- BT_ERR("EnableAdapterLe failed: %s", error->message);
- _bt_adapter_set_status(BT_DEACTIVATED);
+ BT_ERR("EnableAdapterLe failed: %s", error->message);
+ _bt_adapter_set_status(BT_DEACTIVATED);
g_clear_error(&error);
error = NULL;
result = g_dbus_proxy_call_sync(proxy,
g_clear_error(&error);
}
g_variant_unref(result);
-#ifndef USB_BLUETOOTH
/* Terminate myself */
- g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
-#endif
+ if (!TIZEN_FEATURE_BT_USB_DONGLE)
+ g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
return BLUETOOTH_ERROR_INTERNAL;
}
g_variant_unref(result);
- if (le_status == BT_LE_ACTIVATED) {
+ if (le_status == BT_LE_ACTIVATED)
__bt_set_enabled();
- } else {
+ else
_bt_adapter_start_enable_timer();
- }
return BLUETOOTH_ERROR_NONE;
}
BT_DBG("");
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
device_list = g_array_new(FALSE, FALSE, sizeof(gchar));
return BLUETOOTH_ERROR_NONE;
}
+int _bt_disable_adapter_check_status(void)
+{
+ bt_status_t status = _bt_adapter_get_status();
+
+ BT_DBG("");
+
+ if (status == BT_DEACTIVATING) {
+ BT_DBG("Disabling in progress");
+ return BLUETOOTH_ERROR_IN_PROGRESS;
+ }
+
+ if (status == BT_DEACTIVATED) {
+ BT_DBG("Already disabled");
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
int _bt_disable_adapter(void)
{
BT_DBG("+");
g_source_remove(timer_id);
timer_id = 0;
}
+/* unregister all the services/servers/profiles registered on bluez-adapter
+ once adapter is removed, reinitializing of the state-varaibles becomes
+ a problem */
+ if (_bt_unregister_obex_server() != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Fail to unregister obex server");
+ if (_bt_unregister_media_player() != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Fail to unregister media player");
+
+/* Other unregister APIs should be placed here */
__bt_disconnect_all();
ret = _bt_disable_cb();
g_variant_unref(result);
/* Terminate myself */
- if (_bt_adapter_get_status() == BT_DEACTIVATED) {
+ if (_bt_adapter_get_status() == BT_DEACTIVATED)
g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
- }
return BLUETOOTH_ERROR_NONE;
}
-#ifndef TIZEN_TV
int _bt_check_adapter(int *status)
{
-
+if (!TIZEN_PROFILE_TV) {
char *adapter_path = NULL;
BT_CHECK_PARAMETER(status, return);
g_free(adapter_path);
return BLUETOOTH_ERROR_NONE;
-}
-#else
-int _bt_check_adapter(int *status)
-{
+} else {
GDBusProxy *proxy;
GError *error = NULL;
GVariant *result;
g_variant_unref(temp);
return BLUETOOTH_ERROR_NONE;
}
-#endif
+}
int _bt_enable_adapter_le(void)
{
address = g_variant_get_string(temp, NULL);
BT_DBG("Address:%s", address);
- if (address) {
+ if (address)
_bt_convert_addr_string_to_type(local_address->addr, address);
- } else {
+ else
return BLUETOOTH_ERROR_INTERNAL;
- }
g_variant_unref(result);
g_variant_unref(temp);
GError *error = NULL;
GDBusProxy *proxy;
GVariant *result;
+#ifdef TIZEN_FEATURE_BT_DPM
+ int discoverable_state = DPM_BT_ERROR;
+#endif
proxy = _bt_get_adapter_properties_proxy();
retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
-#ifdef TIZEN_DPM_ENABLE
+#ifdef TIZEN_FEATURE_BT_DPM
+ _bt_dpm_get_bluetooth_limited_discoverable_state(&discoverable_state);
if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE &&
- _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
- _bt_launch_dpm_popup("DPM_POLICY_DISABLE_BT_HANDSFREE");
+ discoverable_state == DPM_RESTRICTED) {
+ if (headed_plugin_info->plugin_headed_enabled)
+ headed_plugin_info->headed_plugin->bt_launch_dpmpopup("DPM_POLICY_DISABLE_BT_HANDSFREE");
+
return BLUETOOTH_ERROR_ACCESS_DENIED;
}
if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE &&
- _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
- _bt_launch_dpm_popup("DPM_POLICY_DISABLE_BT");
+ discoverable_state == DPM_RESTRICTED) {
+ if (headed_plugin_info->plugin_headed_enabled)
+ headed_plugin_info->headed_plugin->bt_launch_dpmpopup("DPM_POLICY_DISABLE_BT");
+
return BLUETOOTH_ERROR_ACCESS_DENIED;
}
#endif
return BLUETOOTH_ERROR_INTERNAL;
}
- is_discovering = TRUE;
+ discovery_req = TRUE;
cancel_by_user = FALSE;
/* discovery status will be change in event */
g_variant_unref(result);
return BLUETOOTH_ERROR_INTERNAL;
}
- is_discovering = TRUE;
+ discovery_req = TRUE;
cancel_by_user = FALSE;
/* discovery status will be change in event */
g_variant_unref(result);
return ret;
}
+ discovery_req = FALSE;
cancel_by_user = TRUE;
/* discovery status will be change in event */
g_variant_unref(result);
gboolean _bt_is_discovering(void)
{
- return is_discovering;
+ return (is_discovering || discovery_req);
}
gboolean _bt_is_connectable(void)
return BLUETOOTH_ERROR_INTERNAL;
}
- BT_INFO("### Set connectable [%d]", is_connectable);
+ BT_INFO_C("### Set connectable [%d]", is_connectable);
g_variant_unref(result);
return BLUETOOTH_ERROR_NONE;
}
} else if (strcasecmp(key, "ManufacturerData") == 0) {
manufacturer_data = g_byte_array_new();
g_variant_get(value, "ay", &char_value_iter);
- while (g_variant_iter_loop(char_value_iter, "y", &char_value)) {
+ while (g_variant_iter_loop(char_value_iter, "y", &char_value))
g_byte_array_append(manufacturer_data, &char_value, 1);
- }
+
if (manufacturer_data) {
- if (manufacturer_data->len > 0) {
+ if (manufacturer_data->len > 0)
memcpy(dev_info->manufacturer_data.data, manufacturer_data->data, manufacturer_data->len);
- }
}
g_variant_iter_free(char_value_iter);
g_byte_array_free(manufacturer_data, TRUE);
GVariantIter *iter = NULL;
GError *error = NULL;
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
manager_proxy = _bt_get_manager_proxy();
GDBusProxy *device_proxy = NULL;
gboolean is_connected = FALSE;
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
manager_proxy = _bt_get_manager_proxy();
return ret;
}
+int _bt_is_alias_set(bluetooth_device_address_t *device_address, gboolean *is_alias_set)
+{
+ char *object_path = NULL;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ gboolean alias_set = FALSE;
+
+ GDBusConnection *conn;
+ GDBusProxy *device_proxy;
+ GError *error = NULL;
+ GVariant *result = NULL;
+ GVariant *temp = NULL;
+
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_PARAMETER(is_alias_set, return);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ object_path = _bt_get_device_object_path(address);
+ retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
+
+ conn = _bt_gdbus_get_system_gconn();
+ if (conn == NULL) {
+ g_free(object_path);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ BT_BLUEZ_NAME,
+ object_path,
+ BT_PROPERTIES_INTERFACE,
+ NULL, NULL);
+ if (device_proxy == NULL) {
+ g_free(object_path);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ result = g_dbus_proxy_call_sync(device_proxy, "Get",
+ g_variant_new("(ss)", BT_DEVICE_INTERFACE, "IsAliasSet"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+
+ if (!result) {
+ BT_ERR("Error occured in Proxy call");
+ if (error != NULL) {
+ BT_ERR("Getting is_alias_set property failed: [%s]\n", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(device_proxy);
+ g_free(object_path);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ g_variant_get(result, "(v)", &temp);
+ alias_set = g_variant_get_boolean(temp);
+ *is_alias_set = alias_set;
+ BT_DBG("address: [%s] | *is_alias_set: %s", address, *is_alias_set ? "TRUE" : "FALSE");
+ g_variant_unref(temp);
+ g_variant_unref(result);
+ g_object_unref(device_proxy);
+
+ g_free(object_path);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
int _bt_get_timeout_value(int *timeout)
{
time_t current_time;
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < (m_data->data_len) + 2; i++) {
+ for (i = 0; i < (m_data->data_len) + 2; i++)
g_variant_builder_add(builder, "y", m_data->data[i]);
- }
val = g_variant_new("(ay)", builder);
}
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < (m_data->data_len) + 2; i++) {
+ for (i = 0; i < (m_data->data_len) + 2; i++)
g_variant_builder_add(builder, "y", m_data->data[i]);
- }
val = g_variant_new("(ay)", builder);
int result = BLUETOOTH_ERROR_NONE;
bt_service_alarm_t *alarm = NULL;
- if(!call_back || !alarm_id)
+ if (!call_back || !alarm_id)
return BLUETOOTH_ERROR_INVALID_PARAM;
if (!alarm_mgr.is_alarm_initialized) {
result = alarmmgr_init("bt-service");
if (result != 0) {
- BT_ERR("Failed to initialize alarm = %d",result);
+ BT_ERR("Failed to initialize alarm = %d", result);
result = BLUETOOTH_ERROR_INTERNAL;
goto finish;
}
result = alarmmgr_set_cb(alarm_cb, NULL);
if (result != 0) {
- BT_ERR("Failed to set the callback = %d",result);
+ BT_ERR("Failed to set the callback = %d", result);
result = BLUETOOTH_ERROR_INTERNAL;
goto finish;
}
}
alarm = g_malloc0(sizeof(bt_service_alarm_t));
- if(!alarm)
+ if (!alarm)
return BLUETOOTH_ERROR_MEMORY_ALLOCATION;
result = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE, timeout,
0, NULL, alarm_id);
if (result != 0) {
- BT_ERR("Failed to create alarm error = %d",result);
+ BT_ERR("Failed to create alarm error = %d", result);
result = BLUETOOTH_ERROR_INTERNAL;
g_free(alarm);
goto finish;
gint compare_alarm(gconstpointer list_data, gconstpointer data)
{
+#ifdef ARCH64
+ alarm_id_t alarm_id = (alarm_id_t)(uintptr_t)data;
+#else
alarm_id_t alarm_id = (alarm_id_t)data;
+#endif
bt_service_alarm_t *p_data = (bt_service_alarm_t *)list_data;
- if (p_data->alarm_id == alarm_id) {
+ if (p_data->alarm_id == alarm_id)
return 0;
- }
+
return 1;
}
static gboolean _bt_adapter_request_delayed_cb(gpointer user_data)
{
int result;
+#ifdef ARCH64
+ int function = (int)(uintptr_t)user_data;
+#else
int function = (int)user_data;
+#endif
switch (function) {
case BT_ENABLE_ADAPTER:
int _bt_adapter_request_delayed(int function)
{
- bt_status_t status = _bt_adapter_get_status();
- bt_le_status_t le_status = _bt_adapter_get_le_status();
+ int ret;
switch (function) {
case BT_ENABLE_ADAPTER:
- if (status == BT_ACTIVATING) {
- BT_ERR("Enabling in progress");
- return BLUETOOTH_ERROR_IN_PROGRESS;
- }
-
- if (status == BT_ACTIVATED) {
- BT_ERR("Already enabled");
- return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
- }
-
- if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
- BT_ERR("Disabling in progress");
- return BLUETOOTH_ERROR_DEVICE_BUSY;
- }
+ ret = _bt_enable_adapter_check_status();
+ if (ret == BLUETOOTH_ERROR_NONE)
+ _bt_adapter_set_status(BT_ACTIVATING);
+ else
+ return ret;
break;
case BT_DISABLE_ADAPTER:
- if (status == BT_DEACTIVATING) {
- BT_DBG("Disabling in progress");
- return BLUETOOTH_ERROR_IN_PROGRESS;
- }
-
- if (status == BT_DEACTIVATED) {
- BT_DBG("Already disabled");
- return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
- }
+ ret = _bt_disable_adapter_check_status();
+ if (ret == BLUETOOTH_ERROR_NONE)
+ _bt_adapter_set_status(BT_DEACTIVATING);
+ else
+ return ret;
break;
default:
return BLUETOOTH_ERROR_INTERNAL;
}
- g_idle_add((GSourceFunc)_bt_adapter_request_delayed_cb, (void*)function);
+#ifdef ARCH64
+ g_idle_add((GSourceFunc)_bt_adapter_request_delayed_cb, (void *)(uintptr_t)function);
+#else
+ g_idle_add((GSourceFunc)_bt_adapter_request_delayed_cb, (void *)function);
+#endif
return BLUETOOTH_ERROR_NONE;
}
-#ifdef TIZEN_TV
int _bt_get_enable_timer_id(void)
{
return timer_id;
}
-#endif
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff