#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 guint hf_bluez_id;
static guint hs_bluez_id;
static guint app_id;
-#ifdef TIZEN_MEDIA_ENHANCE
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
static int media_sig_id = -1;
static int media_state_sig_id = -1;
static bt_ag_media_transport_state_t transport_state;
#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>";
#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 */
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)
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)
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_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;
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;
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
codec = BT_CVSD_CODEC_ID;
-#endif
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);
}
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;
+ }
+ }
}
static gboolean __bt_ag_check_nval(GIOChannel *chan)
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)
/* 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);
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;
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;
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");
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);
if (name_owner_sig_id != -1)
g_dbus_connection_signal_unsubscribe(ag_dbus_conn,
name_owner_sig_id);
-#ifdef TIZEN_MEDIA_ENHANCE
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
if (media_sig_id != -1)
g_dbus_connection_signal_unsubscribe(ag_dbus_conn,
media_sig_id);
sco_owner = NULL;
g_object_unref(ag_dbus_conn);
- ag_dbus_conn= NULL;
+ ag_dbus_conn = NULL;
}
return;
}
}
-#ifdef TIZEN_MEDIA_ENHANCE
+#ifdef TIZEN_FEATURE_BT_MEDIA_ENHANCE
void _bt_ag_agent_check_transport_state(void)
{
FN_START;
}
}
g_variant_iter_free(iter);
- g_variant_unref(dict_param);
}
} else if (strcasecmp(signal_name, "ProfileStateChanged") == 0) {
char *profile_uuid = NULL;
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,
owner_sig_id = g_dbus_connection_signal_subscribe(ag_dbus_conn,
NULL, BT_MANAGER_INTERFACE, NULL, 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,
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) {
+void *__bt_ag_agent_telephony_init(void *arg)
+{
int tapi_result;
uint32_t ag_features = *((uint32_t *)arg);
struct sigaction sa;
pthread_t thread_id;
- INFO_C("Starting Bluetooth AG agent");
+ 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;
}