#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 hf_bluez_id;
static guint hs_bluez_id;
static guint app_id;
-#ifdef TIZEN_MEDIA_ENHANCE
-static int media_sig_id = -1;
-static int media_state_sig_id = -1;
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
+static guint media_sig_id = 0;
+static guint media_state_sig_id = 0;
static bt_ag_media_transport_state_t transport_state;
#endif
#define HSP_AG_UUID "00001112-0000-1000-8000-00805f9b34fb"
#define HFP_AG_UUID "0000111f-0000-1000-8000-00805f9b34fb"
-#ifdef TIZEN_MEDIA_ENHANCE
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
#define A2DP_SINK_UUID "0000110b-0000-1000-8000-00805f9b34fb"
#endif
#define DEFAULT_ADAPTER_OBJECT_PATH "/org/bluez/hci0"
-
-#ifdef TIZEN_SUPPORT_LUNAR_DEVICE
#define VCONF_KEY_BT_LUNAR_ENABLED "db/wms/bt_loop_device_hfp_connected"
-#endif
-#if defined(TIZEN_WEARABLE) && defined(TIZEN_BT_HFP_AG_ENABLE)
+#if defined(TIZEN_PROFILE_WEARABLE) && defined(TIZEN_FEATURE_BT_HFP_AG)
#define CALL_APP_ID "org.tizen.call-ui"
#endif
" </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 defined(TIZEN_SUPPORT_DUAL_HF)
gboolean __bt_ag_agent_is_companion_device(const char *addr)
{
-#if defined(TIZEN_WEARABLE)
+#if defined(TIZEN_PROFILE_WEARABLE)
char *host_device_address = NULL;
host_device_address = vconf_get_str(VCONF_KEY_BT_HOST_BT_MAC_ADDR);
dev_addr += 4;
g_strlcpy(address, dev_addr, sizeof(address));
- while ((pos = strchr(address, '_')) != NULL) {
+ while ((pos = strchr(address, '_')) != NULL)
*pos = ':';
- }
g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
}
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;
if (NULL == callapp_type)
return FALSE;
-#if defined(TIZEN_WEARABLE) && defined(TIZEN_BT_HFP_AG_ENABLE)
+#if defined(TIZEN_PROFILE_WEARABLE) && defined(TIZEN_FEATURE_BT_HFP_AG)
*callapp_type = BT_VOICE_CALL;
FN_END;
return TRUE;
if (NULL == condition)
return FALSE;
-#if defined(TIZEN_WEARABLE) && defined(TIZEN_BT_HFP_AG_ENABLE)
+#if defined(TIZEN_PROFILE_WEARABLE) && defined(TIZEN_FEATURE_BT_HFP_AG)
*condition = BT_MO_ONLY_UNLOCKED;
FN_END;
return TRUE;
#endif
}
-#if defined(TIZEN_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_WEARABLE) && defined(TIZEN_BT_HFP_AG_ENABLE)
- 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)
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);
DBG("Value = %d", chld_value);
DBG("Sender = %s", sender);
-#if defined(TIZEN_WEARABLE) && defined(TIZEN_BT_HFP_AG_ENABLE)
+#if defined(TIZEN_PROFILE_WEARABLE) && defined(TIZEN_FEATURE_BT_HFP_AG)
/* Check if AG supports (i.e. ag_chld_str = "0,1,2") the requested CHLD;
if not return FALSE */
if (chld_value != 0 && chld_value != 1 && chld_value != 2)
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,
+ if (ag_dbus_conn)
+ _bt_ag_agent_emit_signal(ag_dbus_conn, hs->path,
BT_AG_SERVICE_NAME, "NrecStatusChanged",
g_variant_new("(b)", status));
FN_END;
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;
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);
{
FN_START;
TelSimImsiInfo_t imsi;
- memset (&imsi, 0, sizeof(TelSimImsiInfo_t));
+ memset(&imsi, 0, sizeof(TelSimImsiInfo_t));
if (tel_get_sim_imsi(tapi_handle, &imsi) != TAPI_API_SUCCESS) {
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_END;
}
-#if defined(TIZEN_WEARABLE) && defined(TIZEN_BT_HFP_AG_ENABLE)
+#if defined(TIZEN_PROFILE_WEARABLE) && defined(TIZEN_FEATURE_BT_HFP_AG)
static gboolean __bt_ag_agent_launch_voice_dial(gboolean activate)
{
FN_START;
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)
{
DBG("Codec negotiation finished");
__bt_ag_sco_connect(data->bt_ag_info);
__bt_ag_codec_negotiation_info_reset(data->bt_ag_info, FALSE);
- g_free (data->codec_status);
- g_free (data);
+ g_free(data->codec_status);
+ g_free(data);
return TRUE;
} else if (g_strcmp0(data->codec_status, "timeout") == 0) {
DBG("Timeout is occured in codec negotiation");
__bt_ag_sco_connect(data->bt_ag_info);
__bt_ag_codec_negotiation_info_reset(data->bt_ag_info, FALSE);
}
- g_free (data->codec_status);
- g_free (data);
+ g_free(data->codec_status);
+ g_free(data);
return FALSE;
}
gboolean init_by_hf)
{
uint32_t codec;
- struct ag_codec *data = g_new0(struct ag_codec, 1);
+ struct ag_codec *data = NULL;;
-#ifdef TIZEN_KIRAN
- 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");
+ data->codec_status = g_strdup("timeout");
hs->codec_info.nego_timer = g_timeout_add_seconds(
HFP_CODEC_NEGOTIATION_TIMEOUT,
err = HFP_STATE_MNGR_ERR_AG_FAILURE;
data->bt_ag_info = hs;
- data->codec_status = g_strdup ("finish");
+ data->codec_status = g_strdup("finish");
_bt_ag_send_response(hs, err);
__bt_ag_codec_negotiation_finished(data);
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)
{
}
void _bt_convert_addr_string_to_type_rev(unsigned char *addr,
- const char *address)
+ const char *address)
{
- int i;
- char *ptr = NULL;
+ int i;
+ char *ptr = NULL;
ret_if(address == NULL);
ret_if(addr == NULL);
- for (i = 0; i < 6; i++) {
- addr[5 - i] = strtol(address, &ptr, 16);
- if (ptr[0] != '\0') {
- if (ptr[0] != ':')
- return;
+ for (i = 0; i < 6; i++) {
+ addr[5 - i] = strtol(address, &ptr, 16);
+ if (ptr[0] != '\0') {
+ if (ptr[0] != ':')
+ return;
- address = ptr + 1;
- }
- }
+ address = ptr + 1;
+ }
+ }
}
+/* LCOV_EXCL_START */
static gboolean __bt_ag_check_nval(GIOChannel *chan)
{
struct pollfd file_desc;
bt_ag_slconn_t *slconn = hs->slc;
/*guint watch_id;*/
+ if (hs->state == HEADSET_STATE_ON_CALL)
+ return BT_HFP_AGENT_ERROR_ALREADY_CONNECTED;
+
if (hs->state != HEADSET_STATE_CONNECTED)
return BT_HFP_AGENT_ERROR_NOT_CONNECTED;
-#ifdef TIZEN_MEDIA_ENHANCE
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
_bt_ag_agent_check_transport_state();
#endif
if (err < 0) {
ERR("ERROR: sco socket set socket option failed");
ERR("Close SCO skt");
+ g_io_channel_unref(io);
close(sco_skt);
return BT_HFP_AGENT_ERROR_INTERNAL;
}
if (err < 0 && !(errno == EINPROGRESS || errno == EAGAIN)) {
ERR("ERROR: sco socket connect failed : %d", err);
ERR("Close SCO skt");
+ g_io_channel_unref(io);
close(sco_skt);
return BT_HFP_AGENT_ERROR_INTERNAL;
}
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");
/* Since SCO server is binded on remote address */
/* Need to stop SCO server once heasdet disconencted*/
- if(hs->sco_server_started)
+ if (hs->sco_server_started)
__bt_ag_stop_sco_server(hs);
g_free(hs->remote_addr);
- g_free(hs->slc);
g_free(hs);
break;
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;
strncpy(s, buf, MAX_BUFFER_SIZE - 1);
- for (i=0; i<num_of_secure_command; i++) {
+ for (i = 0; i < num_of_secure_command; i++) {
if (strstr(buf, secure_command[i])) {
is_security_command = TRUE;
break;
}
}
-done:
/* +XSAT: 11,DISC */
xsat_ptr = strstr(s, "11,DISC,");
if (xsat_ptr) {
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];
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;
DBG("HSP connection completed");
_bt_ag_set_headset_state(bt_ag_info,
HEADSET_STATE_CONNECTED);
- }
- else {
+ } else {
DBG("HFP connection connecting");
_bt_ag_set_headset_state(bt_ag_info,
HEADSET_STATE_CONNECTING);
return FALSE;
}
- token= strtok_r(buffer, "=", &saveptr);
+ token = strtok_r(buffer, "=", &saveptr);
if (token == NULL) {
g_free(buffer);
return FALSE;
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);
GUnixFDList *fd_list;
GVariant *options = NULL;
int device_count = 0;
- GSList *l;
device_count = g_slist_length(active_devices);
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");
if (ret)
goto fail;
- if (local_addr)
- g_free(local_addr);
-
+ g_free(local_addr);
local_addr = g_strdup(address);
DBG("Address = %s\n", local_addr);
g_dbus_method_invocation_return_value(invocation, NULL);
for (l = active_devices; l; l = l->next) {
bt_ag_info_t *data = l->data;
- if(data->state == HEADSET_STATE_ON_CALL) {
+ if (data->state == HEADSET_STATE_ON_CALL) {
__bt_ag_close_sco(data);
_bt_ag_set_headset_state(data,
HEADSET_STATE_CONNECTED);
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, };
for (l = active_devices; l; l = l->next) {
bt_ag_info_t *data = l->data;
- if(data->state == HEADSET_STATE_CONNECTED)
+ if (data->state == HEADSET_STATE_CONNECTED)
is_connected = TRUE;
}
DBG("is_connected : %s",
- is_connected ? "Connected":"Disconnected");
+ is_connected ? "Connected" : "Disconnected");
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(b)", is_connected));
for (l = active_devices; l; l = l->next) {
bt_ag_info_t *data = l->data;
- if(data->state >= HEADSET_STATE_CONNECTED)
+ if (data->state >= HEADSET_STATE_CONNECTED)
_bt_ag_send_at(data, "\r\nRING\r\n");
}
#ifndef __TIZEN_OPEN__
#ifdef MDM_PHASE_2
int mode;
- if ( slconn && FALSE == slconn->is_voice_recognition_running &&
+ if (slconn && FALSE == slconn->is_voice_recognition_running &&
mdm_get_service() == MDM_RESULT_SUCCESS) {
mode = mdm_get_allow_bluetooth_outgoing_call();
mdm_release_service();
for (l = active_devices; l; l = l->next) {
bt_ag_info_t *data = l->data;
- if(data->state > HEADSET_STATE_CONNECTED) {
+ if (data->state > HEADSET_STATE_CONNECTED) {
__bt_ag_close_sco(data);
_bt_ag_set_headset_state(data,
HEADSET_STATE_CONNECTED);
for (l = active_devices; l; l = l->next) {
bt_ag_info_t *data = l->data;
- if(data->state == HEADSET_STATE_ON_CALL)
+ if (data->state == HEADSET_STATE_ON_CALL)
is_playing = TRUE;
}
- DBG("is_playing : %s", is_playing ? "Playing":"Not Playing");
+ DBG("is_playing : %s", is_playing ? "Playing" : "Not Playing");
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(b)", is_playing));
}
g_variant_get(parameters, "(&s)", &cmd);
- if (cmd == NULL){
+ if (cmd == NULL) {
ret = BT_HFP_AGENT_ERROR_INVALID_PARAM;
goto fail;
}
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;
+ 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("-");
FN_START;
GError *error = NULL;
guint owner_id;
- GDBusNodeInfo *node_info;
+ GDBusNodeInfo *node_info = NULL;
gchar *path;
owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
ERR("Failed to register: %s", error->message);
g_error_free(error);
g_free(path);
+ g_dbus_node_info_unref(node_info);
return FALSE;
}
g_free(path);
ERR("Failed to register: %s", error->message);
g_error_free(error);
g_free(path);
+ g_dbus_node_info_unref(node_info);
return FALSE;
}
g_free(path);
+ g_dbus_node_info_unref(node_info);
node_info = __bt_ag_create_method_node_info
(ag_agent_app_introspection_xml);
ERR("Failed to register: %s", error->message);
g_error_free(error);
g_free(path);
+ g_dbus_node_info_unref(node_info);
return FALSE;
}
g_free(path);
+ g_dbus_node_info_unref(node_info);
FN_END;
return TRUE;
_bt_hfp_set_property_value("SignalBarsChanged", signal_bar);
}
-#ifdef TIZEN_SUPPORT_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)
{
ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
(void *)__bt_ag_agent_battery_status_cb, NULL);
- if (0 != ret) {
+ if (0 != ret)
ERR("Subsrciption to battery status failed err = [%d]\n", ret);
- }
ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_RSSI,
(void *)__bt_ag_agent_network_signal_status_cb, NULL);
- if (0 != ret) {
+ if (0 != ret)
ERR("Subsrciption to netowrk signal failed err = [%d]\n", ret);
- }
ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVCTYPE,
(void *)__bt_ag_agent_network_register_status_cb, NULL);
- if (0 != ret) {
+ if (0 != ret)
ERR("Subsrciption to network failed err = [%d]\n", ret);
+
+ 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);
}
-#ifdef TIZEN_SUPPORT_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
}
static void __bt_ag_agent_release_vconf_updates(void)
ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
(vconf_callback_fn)__bt_ag_agent_battery_status_cb);
- if (0 != ret) {
+ if (0 != ret)
ERR("vconf_ignore_key_changed failed\n");
- }
ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_RSSI,
(vconf_callback_fn)__bt_ag_agent_network_signal_status_cb);
- if (0 != ret) {
+ if (0 != ret)
ERR("vconf_ignore_key_changed failed\n");
- }
ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVCTYPE,
(vconf_callback_fn)__bt_ag_agent_network_register_status_cb);
- if (0 != ret) {
+ if (0 != ret)
ERR("vconf_ignore_key_changed failed\n");
- }
}
static gboolean __bt_ag_agent_send_subscriber_number_changed(
g_free(subscriber_number);
}
-static void __bt_ag_agent_on_noti_sim_status (TapiHandle *handle,
+static void __bt_ag_agent_on_noti_sim_status(TapiHandle *handle,
const char *noti_id, void *data, void *user_data)
{
TelSimCardStatus_t *status = data;
}
}
-static void __bt_ag_agent_reg_sim_event (TapiHandle *handle, void *user_data)
+static void __bt_ag_agent_reg_sim_event(TapiHandle *handle, void *user_data)
{
int ret;
ret = tel_register_noti_event(handle, TAPI_NOTI_SIM_STATUS,
ERR("event register failed(%d)", ret);
}
-static void __bt_ag_agent_dereg_sim_event (TapiHandle *handle)
+static void __bt_ag_agent_dereg_sim_event(TapiHandle *handle)
{
int ret;
ret = tel_deregister_noti_event(handle, TAPI_NOTI_SIM_STATUS);
{
FN_START;
char *path = NULL;
- GVariant *optional_param;
+ 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);
ERR("Invalid adapter path");
return;
}
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) {
g_variant_get(parameters, "(&o@as)", &path, &optional_param);
if (!path) {
+ if (optional_param)
+ g_variant_unref(optional_param);
ERR("Invalid adapter path");
return;
}
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 (optional_param)
+ g_variant_unref(optional_param);
+
FN_END;
}
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_MEDIA_ENHANCE
- if (media_sig_id != -1)
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
+ 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;
g_object_unref(ag_dbus_conn);
- ag_dbus_conn= NULL;
+ ag_dbus_conn = NULL;
}
return;
}
return BT_HFP_AGENT_ERROR_INTERNAL;
}
+/* LCOV_EXCL_STOP */
-#ifdef TIZEN_MEDIA_ENHANCE
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
void _bt_ag_agent_check_transport_state(void)
{
FN_START;
if (transport_state == MEDIA_TRANSPORT_STATE_PLAYING) {
GDBusProxy *proxy;
- GVariant *ret;
GError *err = NULL;
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) {
iter, "{sv}", &key, &value_var)) {
DBG("key %s", key);
if (g_strcmp0(key, "State") == 0) {
- value = g_variant_get_string(
+ value = (gchar *)g_variant_get_string(
value_var,
NULL);
DBG("value %s", value);
}
}
g_variant_iter_free(iter);
- g_variant_unref(dict_param);
}
} else if (strcasecmp(signal_name, "ProfileStateChanged") == 0) {
char *profile_uuid = NULL;
}
}
+ if (dict_param)
+ g_variant_unref(dict_param);
+
+ if (optional_param)
+ g_variant_unref(optional_param);
+
FN_END;
}
#endif
+
+/* LCOV_EXCL_START */
static void __bt_ag_agent_dbus_init(void)
{
FN_START;
return;
}
- if(!__bt_ag_agent_get_adapter_path(ag_dbus_conn , NULL)) {
+ if (!__bt_ag_agent_get_adapter_path(ag_dbus_conn , NULL)) {
gchar *path = g_strdup(BT_AG_AGENT_OBJECT_PATH);
__bt_ag_agent_register(path, hfp_ver,
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_MEDIA_ENHANCE
+
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
media_sig_id = g_dbus_connection_signal_subscribe(ag_dbus_conn,
NULL, BT_PROPERTIES_INTERFACE, NULL, NULL,
NULL, 0, __bt_ag_agent_media_filter_cb,
FN_END;
return;
}
+/* LCOV_EXCL_STOP */
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_KIRAN
BT_AG_FEATURE_VOICE_RECOGNITION |
-#endif
BT_AG_FEATURE_EXTENDED_ERROR_RESULT_CODES;
+ }
wbs_en = TRUE;
-#if defined(TIZEN_BT_HFP_AG_ENABLE)
- hfp_ver = HFP_VERSION_1_6;
+#if defined(TIZEN_FEATURE_BT_HFP_AG)
+ 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;
}
-void *__bt_ag_agent_telephony_init(void *arg) {
+/* LCOV_EXCL_START */
+void *__bt_ag_agent_telephony_init(void *arg)
+{
int tapi_result;
uint32_t ag_features = *((uint32_t *)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");
-
- g_type_init();
+ INFO_C("### Starting Bluetooth AG agent");
ag_features = __bt_ag_agent_get_ag_features();
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));
return EXIT_FAILURE;
}
- if (pthread_detach(thread_id) < 0) {
+ if (pthread_detach(thread_id) < 0)
ERR("pthread_detach() is failed");
- }
g_main_loop_run(gmain_loop);
if (gmain_loop)
g_main_loop_unref(gmain_loop);
- INFO_C("Terminating Bluetooth AG agent");
+ INFO_C("### Terminating Bluetooth AG agent");
return 0;
}
+/* LCOV_EXCL_STOP */
projects / platform / core / connectivity / bluetooth-agent.git / blobdiff