#include <bundle_internal.h>
#include "bluetooth-ag-agent.h"
#include "bluetooth-ag-handler.h"
+#include "bluetooth-agent-profile.h"
#include <TapiUtility.h>
#include <ITapiSim.h>
static GMainLoop *gmain_loop = NULL;
static GDBusProxy *service_gproxy;
-static int owner_sig_id = -1;
-static int name_owner_sig_id = -1;
+static guint interface_added_sig_id = 0;
+static guint interface_removed_sig_id = 0;
+static guint name_owner_sig_id = 0;
GDBusConnection *ag_dbus_conn = NULL;
gchar *remote_dev_path = NULL;
gboolean wbs_en;
static guint hs_bluez_id;
static guint app_id;
#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
-static int media_sig_id = -1;
-static int media_state_sig_id = -1;
+static guint media_sig_id = 0;
+static guint media_state_sig_id = 0;
static bt_ag_media_transport_state_t transport_state;
#endif
#define A2DP_SINK_UUID "0000110b-0000-1000-8000-00805f9b34fb"
#endif
#define DEFAULT_ADAPTER_OBJECT_PATH "/org/bluez/hci0"
-
-#ifdef TIZEN_FEATURE_BT_LUNAR_DEVICE
#define VCONF_KEY_BT_LUNAR_ENABLED "db/wms/bt_loop_device_hfp_connected"
-#endif
#if defined(TIZEN_PROFILE_WEARABLE) && defined(TIZEN_FEATURE_BT_HFP_AG)
#define CALL_APP_ID "org.tizen.call-ui"
" </method>"
" <method name='CheckPrivilege'>"
" </method>"
+" <method name='SwapHeadset'>"
+" <arg type='s' name='remote_addr' direction='in'/>"
+" </method>"
" </interface>"
"</node>";
GVariant *parameters,
gpointer user_data);
+/* LCOV_EXCL_START */
static void __bt_convert_addr_type_to_rev_string(char *address,
unsigned char *addr)
{
}
return BT_HFP_AGENT_ERROR_NONE;
}
+/* LCOV_EXCL_STOP */
gboolean _bt_ag_agent_emit_signal(
GDBusConnection *connection,
&error);
if (!ret) {
if (error != NULL) {
+ /* LCOV_EXCL_START */
/* dBUS gives error cause */
ERR("D-Bus API failure: errCode[%x], message[%s]",
error->code, error->message);
g_clear_error(&error);
+ /* LCOV_EXCL_STOP */
}
}
INFO_C("Emit Signal done = [%s]", name);
return ret;
}
+/* LCOV_EXCL_START */
static void __bt_ag_agent_start_watch(bt_ag_info_t *bt_ag_info)
{
bt_ag_info->watch_id = g_io_add_watch(bt_ag_info->io_chan,
if (g_strcmp0(host_device_address, addr) == 0) {
INFO("addr[%s] is companion device", addr);
+ free(host_device_address);
return TRUE;
}
+ free(host_device_address);
+
return FALSE;
#else
/* TODO : Need to add companion device check condition for Phone models */
if (!is_companion_device)
return FALSE;
}
-
return TRUE;
}
#endif /* TIZEN_SUPPORT_DUAL_HF */
+/* LCOV_EXCL_STOP */
static gboolean __bt_is_phone_locked(int *phone_lock_state)
{
ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, phone_lock_state);
if (ret != 0) {
+ /* LCOV_EXCL_START */
ERR("Failed to read [%s]\n", VCONFKEY_IDLE_LOCK_STATE);
return FALSE;
+ /* LCOV_EXCL_STOP */
}
FN_END;
#endif
}
-#if defined(TIZEN_PROFILE_WEARABLE) && defined(TIZEN_TELEPHONY_ENABLED)
+/* LCOV_EXCL_START */
static gboolean __bt_ag_agent_launch_call_app(const char *number)
{
FN_START;
FN_END;
return TRUE;
}
-#endif
static void *__bt_ag_agent_launch_call_req(void *arg)
{
{
FN_START;
-#if defined(TIZEN_PROFILE_WEARABLE) && defined(TIZEN_FEATURE_BT_HFP_AG)
- FN_END;
- return __bt_ag_agent_launch_call_app(number);
-#else
char telnum[BT_MAX_TEL_NUM_STRING];
bundle *b;
pthread_t thread_id;
+ if (TIZEN_PROFILE_WEARABLE)
+ return __bt_ag_agent_launch_call_app(number);
+
if (call_launch_requested == TRUE) {
DBG("Launch request is in progress");
return TRUE;
FN_END;
return TRUE;
-#endif
}
static gboolean __bt_ag_agent_make_video_call(const char *mo_number)
DBG("Sender = %s", sender);
_bt_ag_agent_emit_signal(ag_dbus_conn, path,
- BT_AG_SERVICE_NAME, "Answer",
+ BT_HEADSET_INTERFACE, "Answer",
g_variant_new("(u)", call_id));
FN_END;
return TRUE;
DBG("Sender = %s", sender);
_bt_ag_agent_emit_signal(ag_dbus_conn, path,
- BT_AG_SERVICE_NAME, "Reject",
+ BT_HEADSET_INTERFACE, "Reject",
g_variant_new("(u)", call_id));
FN_END;
return TRUE;
DBG("Sender = %s", sender);
_bt_ag_agent_emit_signal(ag_dbus_conn, path,
- BT_AG_SERVICE_NAME, "Release",
+ BT_HEADSET_INTERFACE, "Release",
g_variant_new("(u)", call_id));
FN_END;
return TRUE;
}
+/* LCOV_EXCL_STOP */
bt_hfp_agent_error_t _bt_ag_agent_dial_num(const gchar *number, guint flags)
{
goto fail;
}
+ /* LCOV_EXCL_START */
if (callapp_type == BT_VIDEO_CALL) {
if (!__bt_ag_agent_make_video_call(number)) {
ERR("Problem launching application");
goto fail;
}
}
+ /* LCOV_EXCL_STOP */
fail:
FN_END;
return BT_HFP_AGENT_ERROR_INTERNAL;
}
+ /* LCOV_EXCL_START */
contacts_filter_create(_contacts_speeddial._uri, &filter);
if (filter == NULL)
FN_END;
return error_code;
+ /* LCOV_EXCL_STOP */
}
+/* LCOV_EXCL_START */
bt_hfp_agent_error_t _bt_ag_agent_send_dtmf(const gchar *dtmf,
const gchar *path, const gchar *sender)
{
if (dtmf == NULL || path == NULL || sender == NULL) {
ERR("Invalid Argument");
- return FALSE;
+ return BT_HFP_AGENT_ERROR_INVALID_PARAM;
}
DBG("Dtmf = %s", dtmf);
return FALSE;
#endif
_bt_ag_agent_emit_signal(ag_dbus_conn, path,
- BT_AG_SERVICE_NAME, "Threeway",
+ BT_HEADSET_INTERFACE, "Threeway",
g_variant_new("(u)", chld_value));
FN_END;
return TRUE;
}
+/* LCOV_EXCL_STOP */
bt_hfp_agent_error_t _bt_ag_agent_dial_last_num(void *device)
{
return err_code;
}
+ /* LCOV_EXCL_START */
contacts_filter_create(_contacts_phone_log._uri, &filter);
if (filter == NULL)
FN_END;
return err_code;
+ /* LCOV_EXCL_STOP */
}
+/* LCOV_EXCL_START */
bt_hfp_agent_error_t _bt_ag_agent_vendor_cmd(const gchar *cmd,
const gchar *path, const gchar *sender)
{
FN_END;
return ret;
}
+/* LCOV_EXCL_STOP */
gboolean _bt_ag_agent_get_signal_quality(void *device)
{
FN_START;
if (vconf_get_int(VCONFKEY_TELEPHONY_RSSI, &rssi)) {
- DBG("VCONFKEY_TELEPHONY_RSSI failed\n");
+ DBG("VCONFKEY_TELEPHONY_RSSI failed\n"); /* LCOV_EXCL_LINE */
goto fail;
}
FN_END;
return TRUE;
fail:
+ /* LCOV_EXCL_START */
FN_END;
_bt_hfp_signal_quality_reply(-1, -1, device);
return FALSE;
+ /* LCOV_EXCL_STOP */
}
gboolean _bt_ag_agent_get_battery_status(void *device)
if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW,
&battery_chrg_status)) {
- DBG("VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW failed\n");
+ DBG("VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW failed\n"); /* LCOV_EXCL_LINE */
goto fail;
}
if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
&battery_capacity)) {
- DBG("VCONFKEY_SYSMAN_BATTERY_CAPACITY failed\n");
+ DBG("VCONFKEY_SYSMAN_BATTERY_CAPACITY failed\n"); /* LCOV_EXCL_LINE */
goto fail;
}
return TRUE;
fail:
+ /* LCOV_EXCL_START */
_bt_hfp_battery_property_reply(device, -1, -1);
FN_END;
return FALSE;
+ /* LCOV_EXCL_STOP */
}
gboolean _bt_ag_agent_get_operator_name(void *device)
operator_name = vconf_get_str(VCONFKEY_TELEPHONY_NWNAME);
if (NULL == operator_name) {
+ /* LCOV_EXCL_START */
DBG("vconf_get_str failed");
_bt_hfp_operator_reply(NULL, device);
return FALSE;
+ /* LCOV_EXCL_STOP */
}
DBG("operator_name = [%s]", operator_name);
else
hs->nrec_status = TRUE;
- _bt_ag_agent_emit_signal(ag_dbus_conn, hs->path,
- BT_AG_SERVICE_NAME, "NrecStatusChanged",
+ if (ag_dbus_conn)
+ _bt_ag_agent_emit_signal(ag_dbus_conn, hs->path,
+ BT_HEADSET_INTERFACE, "NrecStatusChanged",
g_variant_new("(b)", status));
FN_END;
return TRUE;
goto fail;
}
+ /* LCOV_EXCL_START */
if (!g_utf8_validate(imei_number, -1, NULL)) {
free(imei_number);
ERR("get_imei_number : invalid UTF8");
free(imei_number);
FN_END;
return TRUE;
-
+ /* LCOV_EXCL_STOP */
fail:
_bt_hfp_get_imei_number_reply(NULL, device);
FN_END;
void _bt_ag_agent_get_manufacturer_name(void *device)
{
FN_START;
- char *manufacturer_name;
+ char *manufacturer_name = NULL;
int ret;
ret = system_info_get_platform_string("http://tizen.org/system/manufacturer",
&manufacturer_name);
if (SYSTEM_INFO_ERROR_NONE != ret) {
+ /* LCOV_EXCL_START */
ERR("Get manufacturer_name failed : %d", ret);
if (NULL != manufacturer_name)
free(manufacturer_name);
manufacturer_name = g_strdup("Unknown");
+ /* LCOV_EXCL_STOP */
} else if (!g_utf8_validate(manufacturer_name, -1, NULL)) {
+ /* LCOV_EXCL_START */
free(manufacturer_name);
manufacturer_name = g_strdup("Unknown");
ERR("get_manufacturer_name : invalid UTF8");
+ /* LCOV_EXCL_STOP */
}
DBG_SECURE("manufacturer_name = [%s]", manufacturer_name);
ERR("tel_get_sim_imsi failed");
goto fail;
}
+ /* LCOV_EXCL_START */
DBG_SECURE("tapi values %s %s %s", imsi.szMcc, imsi.szMnc, imsi.szMsin);
_bt_hfp_get_imsi_reply(imsi.szMcc, imsi.szMnc, imsi.szMsin, device);
FN_END;
return;
+ /* LCOV_EXCL_STOP */
fail:
_bt_hfp_get_imsi_reply(NULL, NULL, NULL, device);
FN_END;
}
+/* LCOV_EXCL_START */
int _bt_ag_agent_registration_status_convert(int result)
{
switch (result) {
}
return result;
}
+/* LCOV_EXCL_STOP */
void _bt_ag_agent_get_creg_status(void *device)
{
ERR("tel_get_property_int failed");
return;
}
+ /* LCOV_EXCL_START */
registration_status =
_bt_ag_agent_registration_status_convert(result);
FN_END;
return;
+ /* LCOV_EXCL_STOP */
}
void _bt_ag_agent_get_model_name(void *device)
{
FN_START;
- char *model_name;
+ char *model_name = NULL;
int ret;
ret = system_info_get_platform_string("http://tizen.org/system/model_name", &model_name);
void _bt_ag_agent_get_revision_information(void *device)
{
FN_START;
- char *revision_info;
+ char *revision_info = NULL;
int ret;
ret = system_info_get_platform_string("http://tizen.org/system/build.string",
return __bt_ag_agent_launch_voice_dial(activate);
}
+/* LCOV_EXCL_START */
static void __bt_ag_codec_negotiation_info_reset(bt_ag_info_t *hs,
gboolean reset)
{
gboolean init_by_hf)
{
uint32_t codec;
- struct ag_codec *data = g_new0(struct ag_codec, 1);
+ struct ag_codec *data = NULL;;
-#ifdef TIZEN_FEATURE_BT_KIRAN_DEVICE
- codec = BT_CVSD_CODEC_ID;
-#else
- if (hs->codec_info.remote_codecs & BT_MSBC_CODEC_MASK)
- codec = BT_MSBC_CODEC_ID;
- else
+ if (TIZEN_MODEL_NAME_TM1) {
codec = BT_CVSD_CODEC_ID;
-#endif
+ } else {
+ if (hs->codec_info.remote_codecs & BT_MSBC_CODEC_MASK)
+ codec = BT_MSBC_CODEC_ID;
+ else
+ codec = BT_CVSD_CODEC_ID;
+ }
if (wbs_opts.wbs_enable == FALSE)
codec = BT_CVSD_CODEC_ID;
hs->codec_info.requested_by_hf = init_by_hf;
hs->codec_info.final_codec = codec;
+ data = g_new0(struct ag_codec, 1);
+ if (data == NULL)
+ return BT_HFP_AGENT_ERROR_NO_MEMORY;
+
data->bt_ag_info = hs;
data->codec_status = g_strdup("timeout");
for (i = 5; i >= 0; i--, str += 3)
ba->b[i] = strtol(str, NULL, 16);
}
+/* LCOV_EXCL_STOP */
static const char *__bt_ag_state2str(hs_state_t state)
{
}
}
+/* LCOV_EXCL_START */
static gboolean __bt_ag_check_nval(GIOChannel *chan)
{
struct pollfd file_desc;
if (hs->sco_id)
__bt_ag_agent_remove_watch(&hs->sco_id);
+
+ if (hs->sco_incoming_id)
+ __bt_ag_agent_remove_watch(&hs->sco_incoming_id);
}
static gboolean __bt_ag_sco_server_conn_cb(GIOChannel *chan,
if (ag_info->sco_id)
__bt_ag_agent_remove_watch(&ag_info->sco_id);
+ if (ag_info->sco_incoming_id)
+ __bt_ag_agent_remove_watch(&ag_info->sco_incoming_id);
+
if (ag_info->watch_id)
_bt_ag_set_headset_state(ag_info, HEADSET_STATE_CONNECTED);
return FALSE;
}
ag_info->sco = sco_io;
- ag_info->sco_id = g_io_add_watch(sco_io, G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ ag_info->sco_incoming_id = g_io_add_watch(sco_io, G_IO_HUP | G_IO_ERR | G_IO_NVAL,
__bt_ag_sco_server_conn_cb, ag_info);
if (remote_dev_path)
return TRUE;
}
+/* LCOV_EXCL_STOP */
static int __bt_ag_start_sco_server(bt_ag_info_t *hs)
{
return BT_HFP_AGENT_ERROR_INTERNAL;
}
+/* LCOV_EXCL_START */
void __bt_ag_stop_sco_server(bt_ag_info_t *hs)
{
DBG("Stop SCO server");
INFO("STATE CHANGED from [%s(%d)] to [%s(%d)]",
__bt_ag_state2str(org_state), org_state, __bt_ag_state2str(state), state);
}
+/* LCOV_EXCL_STOP */
static struct event at_event_callbacks[] = {
{ "AT+BRSF", _bt_hfp_supported_features },
int num_of_secure_command = 4;
static const char* secure_command[] = {"CLCC", "CLIP", "CPBR", "CCWA"};
-void __bt_ag_agent_print_at_buffer(char *message, const char *buf)
+/* LCOV_EXCL_START */
+static void __bt_ag_agent_print_at_buffer(char *message, const char *buf)
{
int i = 0;
i++;
}
if (message)
- INFO("%s Buffer = [%s], Len(%d)", message, s, strlen(s));
+ INFO("%s Buffer = [%s], Len(%zd)", message, s, strlen(s));
else
INFO("[%s]", s);
}
return -EINVAL;
}
+/* LCOV_EXCL_STOP */
static int __bt_ag_send_at_valist(bt_ag_info_t *hdset, va_list list,
char *list_format)
count = vsnprintf(rsp_buffer, sizeof(rsp_buffer), list_format, list);
if (count < 0) {
- ERR("count is %d", count);
+ ERR("count is %zd", count);
return -EINVAL;
}
}
}
+/* LCOV_EXCL_START */
static gboolean __bt_ag_event_handler(GIOChannel *channel,
GIOCondition cond, void *user_data)
{
size_t available_buffer;
int fd;
bt_ag_info_t *bt_ag_info = (bt_ag_info_t *)user_data;
+ int err_return = 0;
if (cond & G_IO_NVAL)
goto failed;
}
- memcpy(&slconn->buffer[slconn->start], event_buf, len);
+ memcpy(&slconn->buffer[slconn->start + slconn->length], event_buf, len);
slconn->length += len;
slconn->buffer[slconn->start + slconn->length] = '\0';
off_t cmd_len;
get_cr = strchr(&slconn->buffer[slconn->start], '\r');
- if (!get_cr)
+ if (!get_cr) {
+ ERR("Broken AT command received, break");
break;
+ }
- cmd_len = 1 + (off_t) get_cr -
- (off_t) &slconn->buffer[slconn->start];
+ cmd_len = 1 + (off_t)(intptr_t)get_cr -
+ (off_t)(intptr_t)&slconn->buffer[slconn->start];
*get_cr = '\0';
if (cmd_len > 1) {
err = 0;
}
- if (err == -EINVAL) {
- ERR("Unrecognized command: %s",
- &slconn->buffer[slconn->start]);
- err = _bt_ag_send_response(bt_ag_info,
- HFP_STATE_MNGR_ERR_NOT_SUPPORTED);
- if (err < 0)
- goto failed;
- } else if (err < 0)
+ if (err < 0) {
+ switch (err) {
+ case -EINVAL:
+ err_return = HFP_STATE_MNGR_ERR_NOT_SUPPORTED;
+ break;
+ case -EACCES:
+ err_return = HFP_STATE_MNGR_ERR_NOT_ALLOWED;
+ break;
+ default:
+ err_return = HFP_STATE_MNGR_ERR_NOT_SUPPORTED;
+ break;
+ }
ERR("Error handling command %s: %s (%d)",
&slconn->buffer[slconn->start],
strerror(-err), -err);
+ err = _bt_ag_send_response(bt_ag_info,
+ err_return);
+ if (err < 0)
+ goto failed;
+ }
slconn->start += cmd_len;
slconn->length -= cmd_len;
- if (!slconn->length)
+ if (slconn->length <= 0)
slconn->start = 0;
}
return TRUE;
rewind(fp);
- buffer = g_malloc0(sizeof(char) * size);
+ buffer = g_malloc0((sizeof(char) * size) + 1);
if (buffer == NULL) {
ERR("g_malloc0 is failed");
fclose(fp);
return FALSE;
}
+/* LCOV_EXCL_STOP */
/*
* Service level connection complete
_bt_ag_set_headset_state(hs, HEADSET_STATE_CONNECTED);
}
+/* LCOV_EXCL_START */
static gboolean __bt_ag_agent_connection_release(bt_ag_info_t *hs)
{
if (hs->sco) {
__bt_ag_close_sco(hs);
_bt_ag_set_headset_state(hs, HEADSET_STATE_CONNECTED);
- hs->sco = NULL;
}
__bt_ag_agent_remove_watch(&hs->watch_id);
g_variant_get(parameters, "(oha{sv})",
&device_path, &index, &options);
-#if defined(TIZEN_SUPPORT_DUAL_HF)
+
+#if defined(TIZEN_SUPPORT_DUAL_HF) && defined(TIZEN_PROFILE_WEARABLE)
+ /*
+ * Below code is not required for dual HF support for
+ * mobile devices
+ */
if (device_count &&
__bt_ag_agent_check_dual_hf_condition(device_path) == FALSE) {
INFO("not allow to connect 2nd HF connection");
g_free(codec);
g_free(nrec);
+ } else {
+ ret = BT_HFP_AGENT_ERROR_NOT_CONNECTED;
+ goto fail;
}
} else if (g_strcmp0(method_name, "Disconnect") == 0) {
char hdset_address[18] = { 0, };
DBG("Already pass dbus SMACK for bt-service::platform");
/* Return success */
g_dbus_method_invocation_return_value(invocation, NULL);
+ } else if (g_strcmp0(method_name, "SwapHeadset") == 0) {
+ GSList *l;
+ const gchar *addr = NULL;
+ char address[BT_ADDRESS_STRING_SIZE];
+ char remote_addr[BT_ADDRESS_STRING_SIZE];
+ gboolean device_found = FALSE;
+
+ g_variant_get(parameters, "(&s)", &addr);
+ g_strlcpy(address, addr, sizeof(address));
+ DBG("Sender = %s", sender);
+
+ /* Loop through connected headset list
+ * If found, update the remote_dev_path.
+ */
+ for (l = active_devices ; l; l = l->next) {
+ bt_ag_info_t *data = l->data;
+ g_strlcpy(remote_addr, data->remote_addr, sizeof(remote_addr));
+ if (g_strcmp0(remote_addr, address) == 0) {
+ DBG("Active device found");
+ if (data->path == NULL) {
+ DBG("device path is null");
+ ret = BT_HFP_AGENT_ERROR_INTERNAL;
+ goto fail;
+ }
+ remote_dev_path = g_strdup(data->path);
+ DBG("Setting device path %s as active device path", remote_dev_path);
+ device_found = TRUE;
+ break;
+ }
+ }
+
+ if (!device_found) {
+ ret = BT_HFP_AGENT_ERROR_NOT_CONNECTED;
+ goto fail;
+ }
+
+ g_dbus_method_invocation_return_value(invocation, NULL);
}
INFO("-");
_bt_hfp_set_property_value("SignalBarsChanged", signal_bar);
}
-#ifdef TIZEN_FEATURE_BT_LUNAR_DEVICE
static void __bt_ag_agent_lunar_connection_status_cb(keynode_t *node)
{
gboolean status = vconf_keynode_get_bool(node);
}
}
}
-#endif
static void __bt_ag_agent_network_register_status_cb(keynode_t *node)
{
if (0 != ret)
ERR("Subsrciption to network failed err = [%d]\n", ret);
-#ifdef TIZEN_FEATURE_BT_LUNAR_DEVICE
- ret = vconf_notify_key_changed(VCONF_KEY_BT_LUNAR_ENABLED,
- (void *)__bt_ag_agent_lunar_connection_status_cb, NULL);
- if (0 != ret)
- ERR("Subsrciption to lunar connection failed err = [%d]\n", ret);
-
-#endif
+ if (TIZEN_PROFILE_WEARABLE) {
+ ret = vconf_notify_key_changed(VCONF_KEY_BT_LUNAR_ENABLED,
+ (void *)__bt_ag_agent_lunar_connection_status_cb, NULL);
+ if (0 != ret)
+ ERR("Subsrciption to lunar connection failed err = [%d]\n", ret);
+ }
}
static void __bt_ag_agent_release_vconf_updates(void)
gpointer user_data)
{
FN_START;
- char *name_owner = NULL;
- char *old_owner = NULL;
- char *new_owner = NULL;
+ const char *name_owner = NULL;
+ const char *old_owner = NULL;
+ const char *new_owner = NULL;
if (strcasecmp(signal_name, "NameOwnerChanged") == 0) {
GSList *l;
- g_variant_get(parameters, "(sss)", &name_owner, &old_owner, &new_owner);
+ g_variant_get(parameters, "(&s&s&s)", &name_owner, &old_owner, &new_owner);
_bt_hfp_release_all_calls_by_sender(name_owner);
GVariant *optional_param = NULL;
if (strcasecmp(signal_name, "InterfacesAdded") == 0) {
-
- g_variant_get(parameters, "(&o@a{sa{sv}})",
- &path, &optional_param);
+ g_variant_get(parameters, "(&o@a{sa{sv}})", &path, &optional_param);
if (!path) {
if (optional_param)
g_variant_unref(optional_param);
INFO("Adapter Path = [%s]", path);
if (strcasecmp(path, DEFAULT_ADAPTER_OBJECT_PATH) == 0) {
- gchar *path = g_strdup(BT_AG_AGENT_OBJECT_PATH);
- __bt_ag_agent_register(path, hfp_ver,
+ gchar *obj_path = g_strdup(BT_AG_AGENT_OBJECT_PATH);
+ __bt_ag_agent_register(obj_path, hfp_ver,
HFP_AG_UUID, "Hands-Free Audio Gateway");
- path = g_strdup(BT_HS_AG_AGENT_OBJECT_PATH);
- __bt_ag_agent_register(path, hsp_ver,
+ obj_path = g_strdup(BT_HS_AG_AGENT_OBJECT_PATH);
+ __bt_ag_agent_register(obj_path, hsp_ver,
HSP_AG_UUID, "Headset Audio Gateway");
}
} else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
INFO("Adapter Path = [%s]", path);
if (strcasecmp(path, DEFAULT_ADAPTER_OBJECT_PATH) == 0) {
- gchar *path = g_strdup(BT_AG_AGENT_OBJECT_PATH);
- __bt_ag_agent_unregister(path);
+ gchar *obj_path = g_strdup(BT_AG_AGENT_OBJECT_PATH);
+ __bt_ag_agent_unregister(obj_path);
- path = g_strdup(BT_HS_AG_AGENT_OBJECT_PATH);
- __bt_ag_agent_unregister(path);
+ obj_path = g_strdup(BT_HS_AG_AGENT_OBJECT_PATH);
+ __bt_ag_agent_unregister(obj_path);
}
}
if (ag_dbus_conn) {
__bt_ag_unregister_profile_methods();
- if (owner_sig_id != -1)
+ if (interface_added_sig_id)
g_dbus_connection_signal_unsubscribe(ag_dbus_conn,
- owner_sig_id);
+ interface_added_sig_id);
- if (name_owner_sig_id != -1)
+ if (interface_removed_sig_id)
+ g_dbus_connection_signal_unsubscribe(ag_dbus_conn,
+ interface_removed_sig_id);
+
+ if (name_owner_sig_id)
g_dbus_connection_signal_unsubscribe(ag_dbus_conn,
name_owner_sig_id);
#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
- if (media_sig_id != -1)
+ if (media_sig_id)
g_dbus_connection_signal_unsubscribe(ag_dbus_conn,
media_sig_id);
+ media_sig_id = 0;
- if (media_state_sig_id != -1)
+ if (media_state_sig_id)
g_dbus_connection_signal_unsubscribe(ag_dbus_conn,
media_state_sig_id);
+ media_state_sig_id = 0;
#endif
- name_owner_sig_id = -1;
+
+ interface_added_sig_id = 0;
+ interface_removed_sig_id = 0;
+ name_owner_sig_id = 0;
g_free(sco_owner);
sco_owner = NULL;
return BT_HFP_AGENT_ERROR_INTERNAL;
}
+/* LCOV_EXCL_STOP */
#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
+/* LCOV_EXCL_START */
void _bt_ag_agent_check_transport_state(void)
{
FN_START;
proxy = g_dbus_proxy_new_sync(ag_dbus_conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
- "org.PulseAudio2", A2DP_SOURCE_ENDPOINT,
+ "org.pulseaudio.Server", A2DP_SOURCE_ENDPOINT,
BLUEZ_MEDIA_ENDPOINT_INTERFACE, NULL, &err);
if (!proxy) {
}
}
g_variant_iter_free(iter);
- g_variant_unref(dict_param);
}
} else if (strcasecmp(signal_name, "ProfileStateChanged") == 0) {
char *profile_uuid = NULL;
FN_END;
}
+/* LCOV_EXCL_STOP */
#endif
+
+/* LCOV_EXCL_START */
static void __bt_ag_agent_dbus_init(void)
{
FN_START;
HSP_AG_UUID, "Headset Audio Gateway");
}
- owner_sig_id = g_dbus_connection_signal_subscribe(ag_dbus_conn,
- NULL, BT_MANAGER_INTERFACE, NULL, NULL, NULL, 0,
+ interface_added_sig_id = g_dbus_connection_signal_subscribe(ag_dbus_conn,
+ NULL, BT_MANAGER_INTERFACE,
+ BT_INTERFACES_ADDED, NULL, NULL, 0,
+ __bt_ag_agent_filter_cb, NULL, NULL);
+
+ interface_removed_sig_id = g_dbus_connection_signal_subscribe(ag_dbus_conn,
+ NULL, BT_MANAGER_INTERFACE,
+ BT_INTERFACES_REMOVED, NULL, NULL, 0,
__bt_ag_agent_filter_cb, NULL, NULL);
+
#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
media_sig_id = g_dbus_connection_signal_subscribe(ag_dbus_conn,
- NULL, BT_PROPERTIES_INTERFACE, NULL, NULL,
+ BLUEZ_SERVICE_NAME, BT_PROPERTIES_INTERFACE, NULL, NULL,
NULL, 0, __bt_ag_agent_media_filter_cb,
NULL, NULL);
static uint32_t __bt_ag_agent_get_ag_features(void)
{
- uint32_t ag_features = BT_AG_FEATURE_EC_AND_NR |
+ uint32_t ag_features;
+
+ if (TIZEN_MODEL_NAME_TM1) {
+ ag_features = BT_AG_FEATURE_EC_AND_NR |
+ BT_AG_FEATURE_REJECT_CALL |
+ BT_AG_FEATURE_ENHANCED_CALL_STATUS |
+ BT_AG_FEATURE_THREE_WAY_CALL |
+ BT_AG_FEATURE_EXTENDED_ERROR_RESULT_CODES;
+ } else {
+ ag_features = BT_AG_FEATURE_EC_AND_NR |
BT_AG_FEATURE_REJECT_CALL |
BT_AG_FEATURE_ENHANCED_CALL_STATUS |
BT_AG_FEATURE_THREE_WAY_CALL |
-#ifndef TIZEN_FEATURE_BT_KIRAN_DEVICE
BT_AG_FEATURE_VOICE_RECOGNITION |
-#endif
BT_AG_FEATURE_EXTENDED_ERROR_RESULT_CODES;
+ }
wbs_en = TRUE;
#if defined(TIZEN_FEATURE_BT_HFP_AG)
- hfp_ver = HFP_VERSION_1_6;
+ hfp_ver = HFP_VERSION_1_7;
#else
hfp_ver = HFP_VERSION_1_5;
#endif
hsp_ver = HSP_VERSION_1_2;
- if (hfp_ver == HFP_VERSION_1_6)
+ if (hfp_ver > HFP_VERSION_1_5)
ag_features |= BT_AG_FEATURE_CODEC_NEGOTIATION;
+ if (hfp_ver == HFP_VERSION_1_7)
+ ag_features |= BT_AG_FEATURE_ESCO_S4_T2_SUPPORT;
+
return ag_features;
}
+/* LCOV_EXCL_STOP */
+/* LCOV_EXCL_START */
void *__bt_ag_agent_telephony_init(void *arg)
{
int i;
uint32_t ag_features;
struct sigaction sa;
- pthread_t thread_id;
+ pthread_t thread_id = 0;
INFO_C("### Starting Bluetooth AG agent");
ag.sdp_features = (uint16_t) ag_features & 0x1F;
- if (hfp_ver == HFP_VERSION_1_6 && wbs_en == TRUE)
+ if (hfp_ver >= HFP_VERSION_1_6 && wbs_en == TRUE)
ag.sdp_features |= BT_AG_FEATURE_SDP_WIDEBAND_SPEECH;
memset(&sa, 0, sizeof(sa));
INFO_C("### Terminating Bluetooth AG agent");
return 0;
}
+/* LCOV_EXCL_STOP */
projects / platform / core / connectivity / bluetooth-agent.git / blobdiff