diff options
Diffstat (limited to 'audio/headset.c')
| -rw-r--r-- | audio/headset.c | 2951 |
1 files changed, 2951 insertions, 0 deletions
diff --git a/audio/headset.c b/audio/headset.c new file mode 100644 index 0000000..dff10d1 --- /dev/null +++ b/audio/headset.c @@ -0,0 +1,2951 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2006-2010 Nokia Corporation + * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org> + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <stdio.h> +#include <errno.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdlib.h> +#include <stdarg.h> +#include <signal.h> +#include <string.h> +#include <getopt.h> +#include <sys/ioctl.h> +#include <sys/socket.h> +#include <assert.h> + +#include <bluetooth/bluetooth.h> +#include <bluetooth/sdp.h> +#include <bluetooth/sdp_lib.h> + +#include <glib.h> +#include <dbus/dbus.h> +#include <gdbus.h> + +#include "log.h" +#include "device.h" +#include "manager.h" +#include "error.h" +#include "telephony.h" +#include "headset.h" +#include "glib-helper.h" +#include "btio.h" +#include "dbus-common.h" +#include "../src/adapter.h" +#include "../src/device.h" + +#define DC_TIMEOUT 3 + +#define RING_INTERVAL 3 + +#define BUF_SIZE 1024 + +#define HEADSET_GAIN_SPEAKER 'S' +#define HEADSET_GAIN_MICROPHONE 'M' + +static struct { + gboolean telephony_ready; /* Telephony plugin initialized */ + uint32_t features; /* HFP AG features */ + const struct indicator *indicators; /* Available HFP indicators */ + int er_mode; /* Event reporting mode */ + int er_ind; /* Event reporting for indicators */ + int rh; /* Response and Hold state */ + char *number; /* Incoming phone number */ + int number_type; /* Incoming number type */ + guint ring_timer; /* For incoming call indication */ + const char *chld; /* Response to AT+CHLD=? */ +} ag = { + .telephony_ready = FALSE, + .features = 0, + .er_mode = 3, + .er_ind = 0, + .rh = BTRH_NOT_SUPPORTED, + .number = NULL, + .number_type = 0, + .ring_timer = 0, +}; + +static gboolean sco_hci = TRUE; +static gboolean fast_connectable = FALSE; + +static GSList *active_devices = NULL; + +static char *str_state[] = { + "HEADSET_STATE_DISCONNECTED", + "HEADSET_STATE_CONNECTING", + "HEADSET_STATE_CONNECTED", + "HEADSET_STATE_PLAY_IN_PROGRESS", + "HEADSET_STATE_PLAYING", +}; + +struct headset_state_callback { + headset_state_cb cb; + void *user_data; + unsigned int id; +}; + +struct headset_nrec_callback { + unsigned int id; + headset_nrec_cb cb; + void *user_data; +}; + +struct connect_cb { + unsigned int id; + headset_stream_cb_t cb; + void *cb_data; +}; + +struct pending_connect { + DBusMessage *msg; + DBusPendingCall *call; + GIOChannel *io; + int err; + headset_state_t target_state; + GSList *callbacks; + uint16_t svclass; +}; + +struct headset_slc { + char buf[BUF_SIZE]; + int data_start; + int data_length; + + gboolean cli_active; + gboolean cme_enabled; + gboolean cwa_enabled; + gboolean pending_ring; + gboolean inband_ring; + gboolean nrec; + gboolean nrec_req; + + int sp_gain; + int mic_gain; + + unsigned int hf_features; +}; + +struct headset { + uint32_t hsp_handle; + uint32_t hfp_handle; + + int rfcomm_ch; + + GIOChannel *rfcomm; + GIOChannel *tmp_rfcomm; + GIOChannel *sco; + guint sco_id; + + gboolean auto_dc; + + guint dc_timer; + + gboolean hfp_active; + gboolean search_hfp; + + headset_state_t state; + struct pending_connect *pending; + + headset_lock_t lock; + struct headset_slc *slc; + GSList *nrec_cbs; +}; + +struct event { + const char *cmd; + int (*callback) (struct audio_device *device, const char *buf); +}; + +static GSList *headset_callbacks = NULL; + +static void error_connect_failed(DBusConnection *conn, DBusMessage *msg, + int err) +{ + DBusMessage *reply = btd_error_failed(msg, + err < 0 ? strerror(-err) : "Connect failed"); + g_dbus_send_message(conn, reply); +} + +static int rfcomm_connect(struct audio_device *device, headset_stream_cb_t cb, + void *user_data, unsigned int *cb_id); +static int get_records(struct audio_device *device, headset_stream_cb_t cb, + void *user_data, unsigned int *cb_id); + +static void print_ag_features(uint32_t features) +{ + GString *gstr; + char *str; + + if (features == 0) { + DBG("HFP AG features: (none)"); + return; + } + + gstr = g_string_new("HFP AG features: "); + + if (features & AG_FEATURE_THREE_WAY_CALLING) + g_string_append(gstr, "\"Three-way calling\" "); + if (features & AG_FEATURE_EC_ANDOR_NR) + g_string_append(gstr, "\"EC and/or NR function\" "); + if (features & AG_FEATURE_VOICE_RECOGNITION) + g_string_append(gstr, "\"Voice recognition function\" "); + if (features & AG_FEATURE_INBAND_RINGTONE) + g_string_append(gstr, "\"In-band ring tone capability\" "); + if (features & AG_FEATURE_ATTACH_NUMBER_TO_VOICETAG) + g_string_append(gstr, "\"Attach a number to a voice tag\" "); + if (features & AG_FEATURE_REJECT_A_CALL) + g_string_append(gstr, "\"Ability to reject a call\" "); + if (features & AG_FEATURE_ENHANCED_CALL_STATUS) + g_string_append(gstr, "\"Enhanced call status\" "); + if (features & AG_FEATURE_ENHANCED_CALL_CONTROL) + g_string_append(gstr, "\"Enhanced call control\" "); + if (features & AG_FEATURE_EXTENDED_ERROR_RESULT_CODES) + g_string_append(gstr, "\"Extended Error Result Codes\" "); + + str = g_string_free(gstr, FALSE); + + DBG("%s", str); + + g_free(str); +} + +static void print_hf_features(uint32_t features) +{ + GString *gstr; + char *str; + + if (features == 0) { + DBG("HFP HF features: (none)"); + return; + } + + gstr = g_string_new("HFP HF features: "); + + if (features & HF_FEATURE_EC_ANDOR_NR) + g_string_append(gstr, "\"EC and/or NR function\" "); + if (features & HF_FEATURE_CALL_WAITING_AND_3WAY) + g_string_append(gstr, "\"Call waiting and 3-way calling\" "); + if (features & HF_FEATURE_CLI_PRESENTATION) + g_string_append(gstr, "\"CLI presentation capability\" "); + if (features & HF_FEATURE_VOICE_RECOGNITION) + g_string_append(gstr, "\"Voice recognition activation\" "); + if (features & HF_FEATURE_REMOTE_VOLUME_CONTROL) + g_string_append(gstr, "\"Remote volume control\" "); + if (features & HF_FEATURE_ENHANCED_CALL_STATUS) + g_string_append(gstr, "\"Enhanced call status\" "); + if (features & HF_FEATURE_ENHANCED_CALL_CONTROL) + g_string_append(gstr, "\"Enhanced call control\" "); + + str = g_string_free(gstr, FALSE); + + DBG("%s", str); + + g_free(str); +} + +static const char *state2str(headset_state_t state) +{ + switch (state) { + case HEADSET_STATE_DISCONNECTED: + return "disconnected"; + case HEADSET_STATE_CONNECTING: + return "connecting"; + case HEADSET_STATE_CONNECTED: + case HEADSET_STATE_PLAY_IN_PROGRESS: + return "connected"; + case HEADSET_STATE_PLAYING: + return "playing"; + } + + return NULL; +} + +static int headset_send_valist(struct headset *hs, char *format, va_list ap) +{ + char rsp[BUF_SIZE]; + ssize_t total_written, count; + int fd; + + count = vsnprintf(rsp, sizeof(rsp), format, ap); + + if (count < 0) + return -EINVAL; + + if (!hs->rfcomm) { + error("headset_send: the headset is not connected"); + return -EIO; + } + + total_written = 0; + fd = g_io_channel_unix_get_fd(hs->rfcomm); + + while (total_written < count) { + ssize_t written; + + written = write(fd, rsp + total_written, + count - total_written); + if (written < 0) + return -errno; + + total_written += written; + } + + return 0; +} + +static int headset_send(struct headset *hs, char *format, ...) +{ + va_list ap; + int ret; + + va_start(ap, format); + ret = headset_send_valist(hs, format, ap); + va_end(ap); + + return ret; +} + +static int supported_features(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + int err; + + if (strlen(buf) < 9) + return -EINVAL; + + slc->hf_features = strtoul(&buf[8], NULL, 10); + + print_hf_features(slc->hf_features); + + err = headset_send(hs, "\r\n+BRSF: %u\r\n", ag.features); + if (err < 0) + return err; + + return headset_send(hs, "\r\nOK\r\n"); +} + +static char *indicator_ranges(const struct indicator *indicators) +{ + int i; + GString *gstr; + + gstr = g_string_new("\r\n+CIND: "); + + for (i = 0; indicators[i].desc != NULL; i++) { + if (i == 0) + g_string_append_printf(gstr, "(\"%s\",(%s))", + indicators[i].desc, + indicators[i].range); + else + g_string_append_printf(gstr, ",(\"%s\",(%s))", + indicators[i].desc, + indicators[i].range); + } + + g_string_append(gstr, "\r\n"); + + return g_string_free(gstr, FALSE); +} + +static char *indicator_values(const struct indicator *indicators) +{ + int i; + GString *gstr; + + gstr = g_string_new("\r\n+CIND: "); + + for (i = 0; indicators[i].desc != NULL; i++) { + if (i == 0) + g_string_append_printf(gstr, "%d", indicators[i].val); + else + g_string_append_printf(gstr, ",%d", indicators[i].val); + } + + g_string_append(gstr, "\r\n"); + + return g_string_free(gstr, FALSE); +} + +static int report_indicators(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + int err; + char *str; + + if (strlen(buf) < 8) + return -EINVAL; + + if (ag.indicators == NULL) { + error("HFP AG indicators not initialized"); + return headset_send(hs, "\r\nERROR\r\n"); + } + + if (buf[7] == '=') + str = indicator_ranges(ag.indicators); + else + str = indicator_values(ag.indicators); + + err = headset_send(hs, str); + + g_free(str); + + if (err < 0) + return err; + + return headset_send(hs, "\r\nOK\r\n"); +} + +static void pending_connect_complete(struct connect_cb *cb, struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + if (hs->pending->err < 0) + cb->cb(NULL, cb->cb_data); + else + cb->cb(dev, cb->cb_data); +} + +static void pending_connect_finalize(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + struct pending_connect *p = hs->pending; + + if (p == NULL) + return; + + if (p->svclass) + bt_cancel_discovery(&dev->src, &dev->dst); + + g_slist_foreach(p->callbacks, (GFunc) pending_connect_complete, dev); + + g_slist_foreach(p->callbacks, (GFunc) g_free, NULL); + g_slist_free(p->callbacks); + + if (p->io) { + g_io_channel_shutdown(p->io, TRUE, NULL); + g_io_channel_unref(p->io); + } + + if (p->msg) + dbus_message_unref(p->msg); + + if (p->call) { + dbus_pending_call_cancel(p->call); + dbus_pending_call_unref(p->call); + } + + g_free(p); + + hs->pending = NULL; +} + +static void pending_connect_init(struct headset *hs, headset_state_t target_state) +{ + if (hs->pending) { + if (hs->pending->target_state < target_state) + hs->pending->target_state = target_state; + return; + } + + hs->pending = g_new0(struct pending_connect, 1); + hs->pending->target_state = target_state; +} + +static unsigned int connect_cb_new(struct headset *hs, + headset_state_t target_state, + headset_stream_cb_t func, + void *user_data) +{ + struct connect_cb *cb; + unsigned int free_cb_id = 1; + + pending_connect_init(hs, target_state); + + if (!func) + return 0; + + cb = g_new(struct connect_cb, 1); + + cb->cb = func; + cb->cb_data = user_data; + cb->id = free_cb_id++; + + hs->pending->callbacks = g_slist_append(hs->pending->callbacks, + cb); + + return cb->id; +} + +static void send_foreach_headset(GSList *devices, + int (*cmp) (struct headset *hs), + char *format, ...) +{ + GSList *l; + va_list ap; + + for (l = devices; l != NULL; l = l->next) { + struct audio_device *device = l->data; + struct headset *hs = device->headset; + int ret; + + assert(hs != NULL); + + if (cmp && cmp(hs) != 0) + continue; + + va_start(ap, format); + ret = headset_send_valist(hs, format, ap); + if (ret < 0) + error("Failed to send to headset: %s (%d)", + strerror(-ret), -ret); + va_end(ap); + } +} + +static int cli_cmp(struct headset *hs) +{ + struct headset_slc *slc = hs->slc; + + if (!hs->hfp_active) + return -1; + + if (slc->cli_active) + return 0; + else + return -1; +} + +static gboolean ring_timer_cb(gpointer data) +{ + send_foreach_headset(active_devices, NULL, "\r\nRING\r\n"); + + if (ag.number) + send_foreach_headset(active_devices, cli_cmp, + "\r\n+CLIP: \"%s\",%d\r\n", + ag.number, ag.number_type); + + return TRUE; +} + +static void sco_connect_cb(GIOChannel *chan, GError *err, gpointer user_data) +{ + int sk; + struct audio_device *dev = user_data; + struct headset *hs = dev->headset; + struct headset_slc *slc = hs->slc; + struct pending_connect *p = hs->pending; + + if (err) { + error("%s", err->message); + + if (p != NULL) { + p->err = -errno; + if (p->msg) + error_connect_failed(dev->conn, p->msg, p->err); + pending_connect_finalize(dev); + } + + if (hs->rfcomm) + headset_set_state(dev, HEADSET_STATE_CONNECTED); + else + headset_set_state(dev, HEADSET_STATE_DISCONNECTED); + + return; + } + + DBG("SCO socket opened for headset %s", dev->path); + + sk = g_io_channel_unix_get_fd(chan); + + DBG("SCO fd=%d", sk); + + if (p) { + p->io = NULL; + if (p->msg) { + DBusMessage *reply; + reply = dbus_message_new_method_return(p->msg); + g_dbus_send_message(dev->conn, reply); + } + + pending_connect_finalize(dev); + } + + fcntl(sk, F_SETFL, 0); + + headset_set_state(dev, HEADSET_STATE_PLAYING); + + if (slc->pending_ring) { + ring_timer_cb(NULL); + ag.ring_timer = g_timeout_add_seconds(RING_INTERVAL, + ring_timer_cb, + NULL); + slc->pending_ring = FALSE; + } +} + +static int sco_connect(struct audio_device *dev, headset_stream_cb_t cb, + void *user_data, unsigned int *cb_id) +{ + struct headset *hs = dev->headset; + GError *err = NULL; + GIOChannel *io; + + if (hs->state != HEADSET_STATE_CONNECTED) + return -EINVAL; + + io = bt_io_connect(BT_IO_SCO, sco_connect_cb, dev, NULL, &err, + BT_IO_OPT_SOURCE_BDADDR, &dev->src, + BT_IO_OPT_DEST_BDADDR, &dev->dst, + BT_IO_OPT_INVALID); + if (!io) { + error("%s", err->message); + g_error_free(err); + return -EIO; + } + + hs->sco = io; + + headset_set_state(dev, HEADSET_STATE_PLAY_IN_PROGRESS); + + pending_connect_init(hs, HEADSET_STATE_PLAYING); + + if (cb) { + unsigned int id = connect_cb_new(hs, HEADSET_STATE_PLAYING, + cb, user_data); + if (cb_id) + *cb_id = id; + } + + return 0; +} + +static int hfp_cmp(struct headset *hs) +{ + if (hs->hfp_active) + return 0; + else + return -1; +} + +static void hfp_slc_complete(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + struct pending_connect *p = hs->pending; + + DBG("HFP Service Level Connection established"); + + headset_set_state(dev, HEADSET_STATE_CONNECTED); + + if (p == NULL) + return; + + if (p->target_state == HEADSET_STATE_CONNECTED) { + if (p->msg) { + DBusMessage *reply = dbus_message_new_method_return(p->msg); + g_dbus_send_message(dev->conn, reply); + } + pending_connect_finalize(dev); + return; + } + + p->err = sco_connect(dev, NULL, NULL, NULL); + if (p->err < 0) { + if (p->msg) + error_connect_failed(dev->conn, p->msg, p->err); + pending_connect_finalize(dev); + } +} + +static int telephony_generic_rsp(struct audio_device *device, cme_error_t err) +{ + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + + if (err != CME_ERROR_NONE) { + if (slc->cme_enabled) + return headset_send(hs, "\r\n+CME ERROR: %d\r\n", err); + else + return headset_send(hs, "\r\nERROR\r\n"); + } + + return headset_send(hs, "\r\nOK\r\n"); +} + +int telephony_event_reporting_rsp(void *telephony_device, cme_error_t err) +{ + struct audio_device *device = telephony_device; + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + int ret; + + if (err != CME_ERROR_NONE) + return telephony_generic_rsp(telephony_device, err); + + ret = headset_send(hs, "\r\nOK\r\n"); + if (ret < 0) + return ret; + + if (hs->state != HEADSET_STATE_CONNECTING) + return 0; + + if (slc->hf_features & HF_FEATURE_CALL_WAITING_AND_3WAY && + ag.features & AG_FEATURE_THREE_WAY_CALLING) + return 0; + + hfp_slc_complete(device); + + return 0; +} + +static int event_reporting(struct audio_device *dev, const char *buf) +{ + char **tokens; /* <mode>, <keyp>, <disp>, <ind>, <bfr> */ + + if (strlen(buf) < 13) + return -EINVAL; + + tokens = g_strsplit(&buf[8], ",", 5); + if (g_strv_length(tokens) < 4) { + g_strfreev(tokens); + return -EINVAL; + } + + ag.er_mode = atoi(tokens[0]); + ag.er_ind = atoi(tokens[3]); + + g_strfreev(tokens); + tokens = NULL; + + DBG("Event reporting (CMER): mode=%d, ind=%d", + ag.er_mode, ag.er_ind); + + switch (ag.er_ind) { + case 0: + case 1: + telephony_event_reporting_req(dev, ag.er_ind); + break; + default: + return -EINVAL; + } + + return 0; +} + +static int call_hold(struct audio_device *dev, const char *buf) +{ + struct headset *hs = dev->headset; + int err; + + if (strlen(buf) < 9) + return -EINVAL; + + if (buf[8] != '?') { + telephony_call_hold_req(dev, &buf[8]); + return 0; + } + + err = headset_send(hs, "\r\n+CHLD: (%s)\r\n", ag.chld); + if (err < 0) + return err; + + err = headset_send(hs, "\r\nOK\r\n"); + if (err < 0) + return err; + + if (hs->state != HEADSET_STATE_CONNECTING) + return 0; + + hfp_slc_complete(dev); + + return 0; +} + +int telephony_key_press_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +static int key_press(struct audio_device *device, const char *buf) +{ + if (strlen(buf) < 9) + return -EINVAL; + + g_dbus_emit_signal(device->conn, device->path, + AUDIO_HEADSET_INTERFACE, "AnswerRequested", + DBUS_TYPE_INVALID); + + if (ag.ring_timer) { + g_source_remove(ag.ring_timer); + ag.ring_timer = 0; + } + + telephony_key_press_req(device, &buf[8]); + + return 0; +} + +int telephony_answer_call_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +static int answer_call(struct audio_device *device, const char *buf) +{ + if (ag.ring_timer) { + g_source_remove(ag.ring_timer); + ag.ring_timer = 0; + } + + if (ag.number) { + g_free(ag.number); + ag.number = NULL; + } + + telephony_answer_call_req(device); + + return 0; +} + +int telephony_terminate_call_rsp(void *telephony_device, + cme_error_t err) +{ + struct audio_device *device = telephony_device; + struct headset *hs = device->headset; + + if (err != CME_ERROR_NONE) + return telephony_generic_rsp(telephony_device, err); + + g_dbus_emit_signal(device->conn, device->path, + AUDIO_HEADSET_INTERFACE, "CallTerminated", + DBUS_TYPE_INVALID); + + return headset_send(hs, "\r\nOK\r\n"); +} + +static int terminate_call(struct audio_device *device, const char *buf) +{ + if (ag.number) { + g_free(ag.number); + ag.number = NULL; + } + + if (ag.ring_timer) { + g_source_remove(ag.ring_timer); + ag.ring_timer = 0; + } + + telephony_terminate_call_req(device); + + return 0; +} + +static int cli_notification(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + + if (strlen(buf) < 9) + return -EINVAL; + + slc->cli_active = buf[8] == '1' ? TRUE : FALSE; + + return headset_send(hs, "\r\nOK\r\n"); +} + +int telephony_response_and_hold_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +static int response_and_hold(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + + if (strlen(buf) < 8) + return -EINVAL; + + if (ag.rh == BTRH_NOT_SUPPORTED) + return telephony_generic_rsp(device, CME_ERROR_NOT_SUPPORTED); + + if (buf[7] == '=') { + telephony_response_and_hold_req(device, atoi(&buf[8]) < 0); + return 0; + } + + if (ag.rh >= 0) + headset_send(hs, "\r\n+BTRH: %d\r\n", ag.rh); + + return headset_send(hs, "\r\nOK\r\n", ag.rh); +} + +int telephony_last_dialed_number_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +static int last_dialed_number(struct audio_device *device, const char *buf) +{ + telephony_last_dialed_number_req(device); + + return 0; +} + +int telephony_dial_number_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +static int dial_number(struct audio_device *device, const char *buf) +{ + char number[BUF_SIZE]; + size_t buf_len; + + buf_len = strlen(buf); + + if (buf[buf_len - 1] != ';') { + DBG("Rejecting non-voice call dial request"); + return -EINVAL; + } + + memset(number, 0, sizeof(number)); + strncpy(number, &buf[3], buf_len - 4); + + telephony_dial_number_req(device, number); + + return 0; +} + +static int headset_set_gain(struct audio_device *device, uint16_t gain, char type) +{ + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + const char *name, *property; + + if (gain > 15) { + error("Invalid gain value: %u", gain); + return -EINVAL; + } + + switch (type) { + case HEADSET_GAIN_SPEAKER: + if (slc->sp_gain == gain) { + DBG("Ignoring no-change in speaker gain"); + return -EALREADY; + } + name = "SpeakerGainChanged"; + property = "SpeakerGain"; + slc->sp_gain = gain; + break; + case HEADSET_GAIN_MICROPHONE: + if (slc->mic_gain == gain) { + DBG("Ignoring no-change in microphone gain"); + return -EALREADY; + } + name = "MicrophoneGainChanged"; + property = "MicrophoneGain"; + slc->mic_gain = gain; + break; + default: + error("Unknown gain setting"); + return -EINVAL; + } + + g_dbus_emit_signal(device->conn, device->path, + AUDIO_HEADSET_INTERFACE, name, + DBUS_TYPE_UINT16, &gain, + DBUS_TYPE_INVALID); + + emit_property_changed(device->conn, device->path, + AUDIO_HEADSET_INTERFACE, property, + DBUS_TYPE_UINT16, &gain); + + return 0; +} + +static int signal_gain_setting(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + dbus_uint16_t gain; + int err; + + if (strlen(buf) < 8) { + error("Too short string for Gain setting"); + return -EINVAL; + } + + gain = (dbus_uint16_t) strtol(&buf[7], NULL, 10); + + err = headset_set_gain(device, gain, buf[5]); + if (err < 0 && err != -EALREADY) + return err; + + return headset_send(hs, "\r\nOK\r\n"); +} + +int telephony_transmit_dtmf_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +static int dtmf_tone(struct audio_device *device, const char *buf) +{ + char tone; + + if (strlen(buf) < 8) { + error("Too short string for DTMF tone"); + return -EINVAL; + } + + tone = buf[7]; + if (tone >= '#' && tone <= 'D') + telephony_transmit_dtmf_req(device, tone); + else + return -EINVAL; + + return 0; +} + +int telephony_subscriber_number_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +static int subscriber_number(struct audio_device *device, const char *buf) +{ + telephony_subscriber_number_req(device); + + return 0; +} + +int telephony_list_current_calls_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +static int list_current_calls(struct audio_device *device, const char *buf) +{ + telephony_list_current_calls_req(device); + + return 0; +} + +static int extended_errors(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + + if (strlen(buf) < 9) + return -EINVAL; + + if (buf[8] == '1') { + slc->cme_enabled = TRUE; + DBG("CME errors enabled for headset %p", hs); + } else { + slc->cme_enabled = FALSE; + DBG("CME errors disabled for headset %p", hs); + } + + return headset_send(hs, "\r\nOK\r\n"); +} + +static int call_waiting_notify(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + + if (strlen(buf) < 9) + return -EINVAL; + + if (buf[8] == '1') { + slc->cwa_enabled = TRUE; + DBG("Call waiting notification enabled for headset %p", hs); + } else { + slc->cwa_enabled = FALSE; + DBG("Call waiting notification disabled for headset %p", hs); + } + + return headset_send(hs, "\r\nOK\r\n"); +} + +int telephony_operator_selection_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +int telephony_call_hold_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +int telephony_nr_and_ec_rsp(void *telephony_device, cme_error_t err) +{ + struct audio_device *device = telephony_device; + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + + if (err == CME_ERROR_NONE) { + GSList *l; + + for (l = hs->nrec_cbs; l; l = l->next) { + struct headset_nrec_callback *nrec_cb = l->data; + + nrec_cb->cb(device, slc->nrec_req, nrec_cb->user_data); + } + + slc->nrec = hs->slc->nrec_req; + } + + return telephony_generic_rsp(telephony_device, err); +} + +int telephony_voice_dial_rsp(void *telephony_device, cme_error_t err) +{ + return telephony_generic_rsp(telephony_device, err); +} + +int telephony_operator_selection_ind(int mode, const char *oper) +{ + if (!active_devices) + return -ENODEV; + + send_foreach_headset(active_devices, hfp_cmp, + "\r\n+COPS: %d,0,\"%s\"\r\n", + mode, oper); + return 0; +} + +static int operator_selection(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + + if (strlen(buf) < 8) + return -EINVAL; + + switch (buf[7]) { + case '?': + telephony_operator_selection_req(device); + break; + case '=': + return headset_send(hs, "\r\nOK\r\n"); + default: + return -EINVAL; + } + + return 0; +} + +static int nr_and_ec(struct audio_device *device, const char *buf) +{ + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + + if (strlen(buf) < 9) + return -EINVAL; + + if (buf[8] == '0') + slc->nrec_req = FALSE; + else + slc->nrec_req = TRUE; + + telephony_nr_and_ec_req(device, slc->nrec_req); + + return 0; +} + +static int voice_dial(struct audio_device *device, const char *buf) +{ + gboolean enable; + + if (strlen(buf) < 9) + return -EINVAL; + + if (buf[8] == '0') + enable = FALSE; + else + enable = TRUE; + + telephony_voice_dial_req(device, enable); + + return 0; +} + +static struct event event_callbacks[] = { + { "ATA", answer_call }, + { "ATD", dial_number }, + { "AT+VG", signal_gain_setting }, + { "AT+BRSF", supported_features }, + { "AT+CIND", report_indicators }, + { "AT+CMER", event_reporting }, + { "AT+CHLD", call_hold }, + { "AT+CHUP", terminate_call }, + { "AT+CKPD", key_press }, + { "AT+CLIP", cli_notification }, + { "AT+BTRH", response_and_hold }, + { "AT+BLDN", last_dialed_number }, + { "AT+VTS", dtmf_tone }, + { "AT+CNUM", subscriber_number }, + { "AT+CLCC", list_current_calls }, + { "AT+CMEE", extended_errors }, + { "AT+CCWA", call_waiting_notify }, + { "AT+COPS", operator_selection }, + { "AT+NREC", nr_and_ec }, + { "AT+BVRA", voice_dial }, + { 0 } +}; + +static int handle_event(struct audio_device *device, const char *buf) +{ + struct event *ev; + + DBG("Received %s", buf); + + for (ev = event_callbacks; ev->cmd; ev++) { + if (!strncmp(buf, ev->cmd, strlen(ev->cmd))) + return ev->callback(device, buf); + } + + return -EINVAL; +} + +static void close_sco(struct audio_device *device) +{ + struct headset *hs = device->headset; + + if (hs->sco) { + int sock = g_io_channel_unix_get_fd(hs->sco); + shutdown(sock, SHUT_RDWR); + g_io_channel_shutdown(hs->sco, TRUE, NULL); + g_io_channel_unref(hs->sco); + hs->sco = NULL; + } + + if (hs->sco_id) { + g_source_remove(hs->sco_id); + hs->sco_id = 0; + } +} + +static gboolean rfcomm_io_cb(GIOChannel *chan, GIOCondition cond, + struct audio_device *device) +{ + struct headset *hs; + struct headset_slc *slc; + unsigned char buf[BUF_SIZE]; + ssize_t bytes_read; + size_t free_space; + int fd; + + if (cond & G_IO_NVAL) + return FALSE; + + hs = device->headset; + slc = hs->slc; + + if (cond & (G_IO_ERR | G_IO_HUP)) { + DBG("ERR or HUP on RFCOMM socket"); + goto failed; + } + + fd = g_io_channel_unix_get_fd(chan); + + bytes_read = read(fd, buf, sizeof(buf) - 1); + if (bytes_read < 0) + return TRUE; + + free_space = sizeof(slc->buf) - slc->data_start - + slc->data_length - 1; + + if (free_space < (size_t) bytes_read) { + /* Very likely that the HS is sending us garbage so + * just ignore the data and disconnect */ + error("Too much data to fit incomming buffer"); + goto failed; + } + + memcpy(&slc->buf[slc->data_start], buf, bytes_read); + slc->data_length += bytes_read; + + /* Make sure the data is null terminated so we can use string + * functions */ + slc->buf[slc->data_start + slc->data_length] = '\0'; + + while (slc->data_length > 0) { + char *cr; + int err; + off_t cmd_len; + + cr = strchr(&slc->buf[slc->data_start], '\r'); + if (!cr) + break; + + cmd_len = 1 + (off_t) cr - (off_t) &slc->buf[slc->data_start]; + *cr = '\0'; + + if (cmd_len > 1) + err = handle_event(device, &slc->buf[slc->data_start]); + else + /* Silently skip empty commands */ + err = 0; + + if (err == -EINVAL) { + error("Badly formated or unrecognized command: %s", + &slc->buf[slc->data_start]); + err = headset_send(hs, "\r\nERROR\r\n"); + } else if (err < 0) + error("Error handling command %s: %s (%d)", + &slc->buf[slc->data_start], + strerror(-err), -err); + + slc->data_start += cmd_len; + slc->data_length -= cmd_len; + + if (!slc->data_length) + slc->data_start = 0; + } + + return TRUE; + +failed: + headset_set_state(device, HEADSET_STATE_DISCONNECTED); + + return FALSE; +} + +static gboolean sco_cb(GIOChannel *chan, GIOCondition cond, + struct audio_device *device) +{ + if (cond & G_IO_NVAL) + return FALSE; + + error("Audio connection got disconnected"); + + pending_connect_finalize(device); + headset_set_state(device, HEADSET_STATE_CONNECTED); + + return FALSE; +} + +void headset_connect_cb(GIOChannel *chan, GError *err, gpointer user_data) +{ + struct audio_device *dev = user_data; + struct headset *hs = dev->headset; + struct pending_connect *p = hs->pending; + char hs_address[18]; + + if (err) { + error("%s", err->message); + goto failed; + } + + /* For HFP telephony isn't ready just disconnect */ + if (hs->hfp_active && !ag.telephony_ready) { + error("Unable to accept HFP connection since the telephony " + "subsystem isn't initialized"); + goto failed; + } + + hs->rfcomm = hs->tmp_rfcomm; + hs->tmp_rfcomm = NULL; + + ba2str(&dev->dst, hs_address); + + if (p) + p->io = NULL; + else + hs->auto_dc = FALSE; + + g_io_add_watch(chan, G_IO_IN | G_IO_ERR | G_IO_HUP| G_IO_NVAL, + (GIOFunc) rfcomm_io_cb, dev); + + DBG("%s: Connected to %s", dev->path, hs_address); + + hs->slc = g_new0(struct headset_slc, 1); + hs->slc->sp_gain = 15; + hs->slc->mic_gain = 15; + hs->slc->nrec = TRUE; + + /* In HFP mode wait for Service Level Connection */ + if (hs->hfp_active) + return; + + headset_set_state(dev, HEADSET_STATE_CONNECTED); + + if (p && p->target_state == HEADSET_STATE_PLAYING) { + p->err = sco_connect(dev, NULL, NULL, NULL); + if (p->err < 0) + goto failed; + return; + } + + if (p && p->msg) { + DBusMessage *reply = dbus_message_new_method_return(p->msg); + g_dbus_send_message(dev->conn, reply); + } + + pending_connect_finalize(dev); + + return; + +failed: + if (p && p->msg) + error_connect_failed(dev->conn, p->msg, p->err); + pending_connect_finalize(dev); + if (hs->rfcomm) + headset_set_state(dev, HEADSET_STATE_CONNECTED); + else + headset_set_state(dev, HEADSET_STATE_DISCONNECTED); +} + +static int headset_set_channel(struct headset *headset, + const sdp_record_t *record, uint16_t svc) +{ + int ch; + sdp_list_t *protos; + + if (sdp_get_access_protos(record, &protos) < 0) { + error("Unable to get access protos from headset record"); + return -1; + } + + ch = sdp_get_proto_port(protos, RFCOMM_UUID); + + sdp_list_foreach(protos, (sdp_list_func_t) sdp_list_free, NULL); + sdp_list_free(protos, NULL); + + if (ch <= 0) { + error("Unable to get RFCOMM channel from Headset record"); + return -1; + } + + headset->rfcomm_ch = ch; + + if (svc == HANDSFREE_SVCLASS_ID) { + headset->hfp_handle = record->handle; + DBG("Discovered Handsfree service on channel %d", ch); + } else { + headset->hsp_handle = record->handle; + DBG("Discovered Headset service on channel %d", ch); + } + + return 0; +} + +static void get_record_cb(sdp_list_t *recs, int err, gpointer user_data) +{ + struct audio_device *dev = user_data; + struct headset *hs = dev->headset; + struct pending_connect *p = hs->pending; + sdp_record_t *record = NULL; + sdp_list_t *r; + uuid_t uuid; + + assert(hs->pending != NULL); + + if (err < 0) { + error("Unable to get service record: %s (%d)", + strerror(-err), -err); + p->err = -err; + if (p->msg) + error_connect_failed(dev->conn, p->msg, p->err); + goto failed; + } + + if (!recs || !recs->data) { + error("No records found"); + goto failed_not_supported; + } + + sdp_uuid16_create(&uuid, p->svclass); + + for (r = recs; r != NULL; r = r->next) { + sdp_list_t *classes; + uuid_t class; + + record = r->data; + + if (sdp_get_service_classes(record, &classes) < 0) { + error("Unable to get service classes from record"); + continue; + } + + memcpy(&class, classes->data, sizeof(uuid)); + + sdp_list_free(classes, free); + + + if (sdp_uuid_cmp(&class, &uuid) == 0) + break; + } + + if (r == NULL) { + error("No record found with UUID 0x%04x", p->svclass); + goto failed_not_supported; + } + + if (headset_set_channel(hs, record, p->svclass) < 0) { + error("Unable to extract RFCOMM channel from service record"); + goto failed_not_supported; + } + + /* Set svclass to 0 so we can easily check that SDP is no-longer + * going on (to know if bt_cancel_discovery needs to be called) */ + p->svclass = 0; + + err = rfcomm_connect(dev, NULL, NULL, NULL); + if (err < 0) { + error("Unable to connect: %s (%d)", strerror(-err), -err); + p->err = -err; + error_connect_failed(dev->conn, p->msg, p->err); + goto failed; + } + + return; + +failed_not_supported: + if (p->svclass == HANDSFREE_SVCLASS_ID && + get_records(dev, NULL, NULL, NULL) == 0) + return; + if (p->msg) { + DBusMessage *reply = btd_error_not_supported(p->msg); + g_dbus_send_message(dev->conn, reply); + } +failed: + p->svclass = 0; + pending_connect_finalize(dev); + headset_set_state(dev, HEADSET_STATE_DISCONNECTED); +} + +static int get_records(struct audio_device *device, headset_stream_cb_t cb, + void *user_data, unsigned int *cb_id) +{ + struct headset *hs = device->headset; + uint16_t svclass; + uuid_t uuid; + int err; + + if (hs->pending && hs->pending->svclass == HANDSFREE_SVCLASS_ID) + svclass = HEADSET_SVCLASS_ID; + else + svclass = hs->search_hfp ? HANDSFREE_SVCLASS_ID : + HEADSET_SVCLASS_ID; + + sdp_uuid16_create(&uuid, svclass); + + err = bt_search_service(&device->src, &device->dst, &uuid, + get_record_cb, device, NULL); + if (err < 0) + return err; + + if (hs->pending) { + hs->pending->svclass = svclass; + return 0; + } + + headset_set_state(device, HEADSET_STATE_CONNECTING); + + pending_connect_init(hs, HEADSET_STATE_CONNECTED); + + hs->pending->svclass = svclass; + + if (cb) { + unsigned int id; + id = connect_cb_new(hs, HEADSET_STATE_CONNECTED, + cb, user_data); + if (cb_id) + *cb_id = id; + } + + return 0; +} + +static int rfcomm_connect(struct audio_device *dev, headset_stream_cb_t cb, + void *user_data, unsigned int *cb_id) +{ + struct headset *hs = dev->headset; + char address[18]; + GError *err = NULL; + + if (!manager_allow_headset_connection(dev)) + return -ECONNREFUSED; + + if (hs->rfcomm_ch < 0) + return get_records(dev, cb, user_data, cb_id); + + ba2str(&dev->dst, address); + + DBG("%s: Connecting to %s channel %d", dev->path, address, + hs->rfcomm_ch); + + hs->tmp_rfcomm = bt_io_connect(BT_IO_RFCOMM, headset_connect_cb, dev, + NULL, &err, + BT_IO_OPT_SOURCE_BDADDR, &dev->src, + BT_IO_OPT_DEST_BDADDR, &dev->dst, + BT_IO_OPT_CHANNEL, hs->rfcomm_ch, + BT_IO_OPT_INVALID); + + hs->rfcomm_ch = -1; + + if (!hs->tmp_rfcomm) { + error("%s", err->message); + g_error_free(err); + return -EIO; + } + + hs->hfp_active = hs->hfp_handle != 0 ? TRUE : FALSE; + + headset_set_state(dev, HEADSET_STATE_CONNECTING); + + pending_connect_init(hs, HEADSET_STATE_CONNECTED); + + if (cb) { + unsigned int id = connect_cb_new(hs, HEADSET_STATE_CONNECTED, + cb, user_data); + if (cb_id) + *cb_id = id; + } + + return 0; +} + +static DBusMessage *hs_stop(DBusConnection *conn, DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + DBusMessage *reply = NULL; + + if (hs->state < HEADSET_STATE_PLAY_IN_PROGRESS) + return btd_error_not_connected(msg); + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + headset_set_state(device, HEADSET_STATE_CONNECTED); + + return reply; +} + +static DBusMessage *hs_is_playing(DBusConnection *conn, DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + DBusMessage *reply; + dbus_bool_t playing; + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + playing = (hs->state == HEADSET_STATE_PLAYING); + + dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &playing, + DBUS_TYPE_INVALID); + + return reply; +} + +static DBusMessage *hs_disconnect(DBusConnection *conn, DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + char hs_address[18]; + + if (hs->state == HEADSET_STATE_DISCONNECTED) + return btd_error_not_connected(msg); + + headset_shutdown(device); + ba2str(&device->dst, hs_address); + info("Disconnected from %s, %s", hs_address, device->path); + + return dbus_message_new_method_return(msg); + +} + +static DBusMessage *hs_is_connected(DBusConnection *conn, + DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + DBusMessage *reply; + dbus_bool_t connected; + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + connected = (device->headset->state >= HEADSET_STATE_CONNECTED); + + dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connected, + DBUS_TYPE_INVALID); + + return reply; +} + +static DBusMessage *hs_connect(DBusConnection *conn, DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + int err; + + if (hs->state == HEADSET_STATE_CONNECTING) + return btd_error_in_progress(msg); + else if (hs->state > HEADSET_STATE_CONNECTING) + return btd_error_already_connected(msg); + + if (hs->hfp_handle && !ag.telephony_ready) + return btd_error_not_ready(msg); + + device->auto_connect = FALSE; + + err = rfcomm_connect(device, NULL, NULL, NULL); + if (err < 0) + return btd_error_failed(msg, strerror(-err)); + + hs->auto_dc = FALSE; + + hs->pending->msg = dbus_message_ref(msg); + + return NULL; +} + +static DBusMessage *hs_ring(DBusConnection *conn, DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + DBusMessage *reply = NULL; + int err; + + if (hs->state < HEADSET_STATE_CONNECTED) + return btd_error_not_connected(msg); + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + if (ag.ring_timer) { + DBG("IndicateCall received when already indicating"); + goto done; + } + + err = headset_send(hs, "\r\nRING\r\n"); + if (err < 0) { + dbus_message_unref(reply); + return btd_error_failed(msg, strerror(-err)); + } + + ring_timer_cb(NULL); + ag.ring_timer = g_timeout_add_seconds(RING_INTERVAL, ring_timer_cb, + NULL); + +done: + return reply; +} + +static DBusMessage *hs_cancel_call(DBusConnection *conn, + DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + DBusMessage *reply = NULL; + + if (hs->state < HEADSET_STATE_CONNECTED) + return btd_error_not_connected(msg); + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + if (ag.ring_timer) { + g_source_remove(ag.ring_timer); + ag.ring_timer = 0; + } else + DBG("Got CancelCall method call but no call is active"); + + return reply; +} + +static DBusMessage *hs_play(DBusConnection *conn, DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + int err; + + if (sco_hci) { + error("Refusing Headset.Play() because SCO HCI routing " + "is enabled"); + return btd_error_not_available(msg); + } + + switch (hs->state) { + case HEADSET_STATE_DISCONNECTED: + case HEADSET_STATE_CONNECTING: + return btd_error_not_connected(msg); + case HEADSET_STATE_PLAY_IN_PROGRESS: + if (hs->pending && hs->pending->msg == NULL) { + hs->pending->msg = dbus_message_ref(msg); + return NULL; + } + return btd_error_busy(msg); + case HEADSET_STATE_PLAYING: + return btd_error_already_connected(msg); + case HEADSET_STATE_CONNECTED: + default: + break; + } + + err = sco_connect(device, NULL, NULL, NULL); + if (err < 0) + return btd_error_failed(msg, strerror(-err)); + + hs->pending->msg = dbus_message_ref(msg); + + return NULL; +} + +static DBusMessage *hs_get_speaker_gain(DBusConnection *conn, + DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + DBusMessage *reply; + dbus_uint16_t gain; + + if (hs->state < HEADSET_STATE_CONNECTED) + return btd_error_not_available(msg); + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + gain = (dbus_uint16_t) slc->sp_gain; + + dbus_message_append_args(reply, DBUS_TYPE_UINT16, &gain, + DBUS_TYPE_INVALID); + + return reply; +} + +static DBusMessage *hs_get_mic_gain(DBusConnection *conn, + DBusMessage *msg, + void *data) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + struct headset_slc *slc = hs->slc; + DBusMessage *reply; + dbus_uint16_t gain; + + if (hs->state < HEADSET_STATE_CONNECTED || slc == NULL) + return btd_error_not_available(msg); + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + gain = (dbus_uint16_t) slc->mic_gain; + + dbus_message_append_args(reply, DBUS_TYPE_UINT16, &gain, + DBUS_TYPE_INVALID); + + return reply; +} + +static DBusMessage *hs_set_gain(DBusConnection *conn, + DBusMessage *msg, + void *data, uint16_t gain, + char type) +{ + struct audio_device *device = data; + struct headset *hs = device->headset; + DBusMessage *reply; + int err; + + if (hs->state < HEADSET_STATE_CONNECTED) + return btd_error_not_connected(msg); + + err = headset_set_gain(device, gain, type); + if (err < 0) + return btd_error_invalid_args(msg); + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + if (hs->state == HEADSET_STATE_PLAYING) { + err = headset_send(hs, "\r\n+VG%c=%u\r\n", type, gain); + if (err < 0) { + dbus_message_unref(reply); + return btd_error_failed(msg, strerror(-err)); + } + } + + return reply; +} + +static DBusMessage *hs_set_speaker_gain(DBusConnection *conn, + DBusMessage *msg, + void *data) +{ + uint16_t gain; + + if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_UINT16, &gain, + DBUS_TYPE_INVALID)) + return NULL; + + return hs_set_gain(conn, msg, data, gain, HEADSET_GAIN_SPEAKER); +} + +static DBusMessage *hs_set_mic_gain(DBusConnection *conn, + DBusMessage *msg, + void *data) +{ + uint16_t gain; + + if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_UINT16, &gain, + DBUS_TYPE_INVALID)) + return NULL; + + return hs_set_gain(conn, msg, data, gain, HEADSET_GAIN_MICROPHONE); +} + +static DBusMessage *hs_get_properties(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct audio_device *device = data; + DBusMessage *reply; + DBusMessageIter iter; + DBusMessageIter dict; + gboolean value; + const char *state; + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + dbus_message_iter_init_append(reply, &iter); + + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); + + + /* Playing */ + value = (device->headset->state == HEADSET_STATE_PLAYING); + dict_append_entry(&dict, "Playing", DBUS_TYPE_BOOLEAN, &value); + + /* State */ + state = state2str(device->headset->state); + if (state) + dict_append_entry(&dict, "State", DBUS_TYPE_STRING, &state); + + /* Connected */ + value = (device->headset->state >= HEADSET_STATE_CONNECTED); + dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &value); + + if (!value) + goto done; + + /* SpeakerGain */ + dict_append_entry(&dict, "SpeakerGain", + DBUS_TYPE_UINT16, + &device->headset->slc->sp_gain); + + /* MicrophoneGain */ + dict_append_entry(&dict, "MicrophoneGain", + DBUS_TYPE_UINT16, + &device->headset->slc->mic_gain); + +done: + dbus_message_iter_close_container(&iter, &dict); + + return reply; +} + +static DBusMessage *hs_set_property(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *property; + DBusMessageIter iter; + DBusMessageIter sub; + uint16_t gain; + + if (!dbus_message_iter_init(msg, &iter)) + return btd_error_invalid_args(msg); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) + return btd_error_invalid_args(msg); + + dbus_message_iter_get_basic(&iter, &property); + dbus_message_iter_next(&iter); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) + return btd_error_invalid_args(msg); + dbus_message_iter_recurse(&iter, &sub); + + if (g_str_equal("SpeakerGain", property)) { + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT16) + return btd_error_invalid_args(msg); + + dbus_message_iter_get_basic(&sub, &gain); + return hs_set_gain(conn, msg, data, gain, + HEADSET_GAIN_SPEAKER); + } else if (g_str_equal("MicrophoneGain", property)) { + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT16) + return btd_error_invalid_args(msg); + + dbus_message_iter_get_basic(&sub, &gain); + return hs_set_gain(conn, msg, data, gain, + HEADSET_GAIN_MICROPHONE); + } + + return btd_error_invalid_args(msg); +} +static GDBusMethodTable headset_methods[] = { + { "Connect", "", "", hs_connect, + G_DBUS_METHOD_FLAG_ASYNC }, + { "Disconnect", "", "", hs_disconnect }, + { "IsConnected", "", "b", hs_is_connected }, + { "IndicateCall", "", "", hs_ring }, + { "CancelCall", "", "", hs_cancel_call }, + { "Play", "", "", hs_play, + G_DBUS_METHOD_FLAG_ASYNC }, + { "Stop", "", "", hs_stop }, + { "IsPlaying", "", "b", hs_is_playing, + G_DBUS_METHOD_FLAG_DEPRECATED }, + { "GetSpeakerGain", "", "q", hs_get_speaker_gain, + G_DBUS_METHOD_FLAG_DEPRECATED }, + { "GetMicrophoneGain", "", "q", hs_get_mic_gain, + G_DBUS_METHOD_FLAG_DEPRECATED }, + { "SetSpeakerGain", "q", "", hs_set_speaker_gain, + G_DBUS_METHOD_FLAG_DEPRECATED }, + { "SetMicrophoneGain", "q", "", hs_set_mic_gain, + G_DBUS_METHOD_FLAG_DEPRECATED }, + { "GetProperties", "", "a{sv}",hs_get_properties }, + { "SetProperty", "sv", "", hs_set_property }, + { NULL, NULL, NULL, NULL } +}; + +static GDBusSignalTable headset_signals[] = { + { "Connected", "", G_DBUS_SIGNAL_FLAG_DEPRECATED }, + { "Disconnected", "", G_DBUS_SIGNAL_FLAG_DEPRECATED }, + { "AnswerRequested", "" }, + { "Stopped", "", G_DBUS_SIGNAL_FLAG_DEPRECATED }, + { "Playing", "", G_DBUS_SIGNAL_FLAG_DEPRECATED }, + { "SpeakerGainChanged", "q", G_DBUS_SIGNAL_FLAG_DEPRECATED }, + { "MicrophoneGainChanged", "q", G_DBUS_SIGNAL_FLAG_DEPRECATED }, + { "CallTerminated", "" }, + { "PropertyChanged", "sv" }, + { NULL, NULL } +}; + +void headset_update(struct audio_device *dev, uint16_t svc, + const char *uuidstr) +{ + struct headset *headset = dev->headset; + const sdp_record_t *record; + + record = btd_device_get_record(dev->btd_dev, uuidstr); + if (!record) + return; + + switch (svc) { + case HANDSFREE_SVCLASS_ID: + if (headset->hfp_handle && + (headset->hfp_handle != record->handle)) { + error("More than one HFP record found on device"); + return; + } + + headset->hfp_handle = record->handle; + break; + + case HEADSET_SVCLASS_ID: + if (headset->hsp_handle && + (headset->hsp_handle != record->handle)) { + error("More than one HSP record found on device"); + return; + } + + headset->hsp_handle = record->handle; + + /* Ignore this record if we already have access to HFP */ + if (headset->hfp_handle) + return; + + break; + + default: + DBG("Invalid record passed to headset_update"); + return; + } +} + +static int headset_close_rfcomm(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + GIOChannel *rfcomm = hs->tmp_rfcomm ? hs->tmp_rfcomm : hs->rfcomm; + + if (rfcomm) { + g_io_channel_shutdown(rfcomm, TRUE, NULL); + g_io_channel_unref(rfcomm); + hs->tmp_rfcomm = NULL; + hs->rfcomm = NULL; + } + + g_free(hs->slc); + hs->slc = NULL; + + return 0; +} + +static void headset_free(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + if (hs->dc_timer) { + g_source_remove(hs->dc_timer); + hs->dc_timer = 0; + } + + close_sco(dev); + + headset_close_rfcomm(dev); + + g_slist_foreach(hs->nrec_cbs, (GFunc) g_free, NULL); + g_slist_free(hs->nrec_cbs); + + g_free(hs); + dev->headset = NULL; +} + +static void path_unregister(void *data) +{ + struct audio_device *dev = data; + struct headset *hs = dev->headset; + + if (hs->state > HEADSET_STATE_DISCONNECTED) { + DBG("Headset unregistered while device was connected!"); + headset_shutdown(dev); + } + + DBG("Unregistered interface %s on path %s", + AUDIO_HEADSET_INTERFACE, dev->path); + + headset_free(dev); +} + +void headset_unregister(struct audio_device *dev) +{ + g_dbus_unregister_interface(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE); +} + +struct headset *headset_init(struct audio_device *dev, uint16_t svc, + const char *uuidstr) +{ + struct headset *hs; + const sdp_record_t *record; + + hs = g_new0(struct headset, 1); + hs->rfcomm_ch = -1; + hs->search_hfp = server_is_enabled(&dev->src, HANDSFREE_SVCLASS_ID); + + record = btd_device_get_record(dev->btd_dev, uuidstr); + if (!record) + goto register_iface; + + switch (svc) { + case HANDSFREE_SVCLASS_ID: + hs->hfp_handle = record->handle; + break; + + case HEADSET_SVCLASS_ID: + hs->hsp_handle = record->handle; + break; + + default: + DBG("Invalid record passed to headset_init"); + g_free(hs); + return NULL; + } + +register_iface: + if (!g_dbus_register_interface(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, + headset_methods, headset_signals, NULL, + dev, path_unregister)) { + g_free(hs); + return NULL; + } + + DBG("Registered interface %s on path %s", + AUDIO_HEADSET_INTERFACE, dev->path); + + return hs; +} + +uint32_t headset_config_init(GKeyFile *config) +{ + GError *err = NULL; + char *str; + + /* Use the default values if there is no config file */ + if (config == NULL) + return ag.features; + + str = g_key_file_get_string(config, "General", "SCORouting", + &err); + if (err) { + DBG("audio.conf: %s", err->message); + g_clear_error(&err); + } else { + if (strcmp(str, "PCM") == 0) + sco_hci = FALSE; + else if (strcmp(str, "HCI") == 0) + sco_hci = TRUE; + else + error("Invalid Headset Routing value: %s", str); + g_free(str); + } + + /* Init fast connectable option */ + str = g_key_file_get_string(config, "Headset", "FastConnectable", + &err); + if (err) { + DBG("audio.conf: %s", err->message); + g_clear_error(&err); + } else { + fast_connectable = strcmp(str, "true") == 0; + if (fast_connectable) + manager_set_fast_connectable(FALSE); + g_free(str); + } + + return ag.features; +} + +static gboolean hs_dc_timeout(struct audio_device *dev) +{ + headset_set_state(dev, HEADSET_STATE_DISCONNECTED); + return FALSE; +} + +gboolean headset_cancel_stream(struct audio_device *dev, unsigned int id) +{ + struct headset *hs = dev->headset; + struct pending_connect *p = hs->pending; + GSList *l; + struct connect_cb *cb = NULL; + + if (!p) + return FALSE; + + for (l = p->callbacks; l != NULL; l = l->next) { + struct connect_cb *tmp = l->data; + + if (tmp->id == id) { + cb = tmp; + break; + } + } + + if (!cb) + return FALSE; + + p->callbacks = g_slist_remove(p->callbacks, cb); + g_free(cb); + + if (p->callbacks || p->msg) + return TRUE; + + if (hs->auto_dc) { + if (hs->rfcomm) + hs->dc_timer = g_timeout_add_seconds(DC_TIMEOUT, + (GSourceFunc) hs_dc_timeout, + dev); + else + headset_set_state(dev, HEADSET_STATE_DISCONNECTED); + } + + return TRUE; +} + +static gboolean dummy_connect_complete(struct audio_device *dev) +{ + pending_connect_finalize(dev); + return FALSE; +} + +unsigned int headset_request_stream(struct audio_device *dev, + headset_stream_cb_t cb, + void *user_data) +{ + struct headset *hs = dev->headset; + unsigned int id; + + if (hs->state == HEADSET_STATE_PLAYING) { + id = connect_cb_new(hs, HEADSET_STATE_PLAYING, cb, user_data); + g_idle_add((GSourceFunc) dummy_connect_complete, dev); + return id; + } + + if (hs->dc_timer) { + g_source_remove(hs->dc_timer); + hs->dc_timer = 0; + } + + if (hs->state == HEADSET_STATE_CONNECTING || + hs->state == HEADSET_STATE_PLAY_IN_PROGRESS) + return connect_cb_new(hs, HEADSET_STATE_PLAYING, cb, user_data); + + if (hs->rfcomm == NULL) { + if (rfcomm_connect(dev, cb, user_data, &id) < 0) + return 0; + hs->auto_dc = TRUE; + } else if (sco_connect(dev, cb, user_data, &id) < 0) + return 0; + + hs->pending->target_state = HEADSET_STATE_PLAYING; + + return id; +} + +unsigned int headset_config_stream(struct audio_device *dev, + gboolean auto_dc, + headset_stream_cb_t cb, + void *user_data) +{ + struct headset *hs = dev->headset; + unsigned int id = 0; + + if (hs->dc_timer) { + g_source_remove(hs->dc_timer); + hs->dc_timer = 0; + } + + if (hs->state == HEADSET_STATE_CONNECTING) + return connect_cb_new(hs, HEADSET_STATE_CONNECTED, cb, + user_data); + + if (hs->rfcomm) + goto done; + + if (rfcomm_connect(dev, cb, user_data, &id) < 0) + return 0; + + hs->auto_dc = auto_dc; + hs->pending->target_state = HEADSET_STATE_CONNECTED; + + return id; + +done: + id = connect_cb_new(hs, HEADSET_STATE_CONNECTED, cb, user_data); + g_idle_add((GSourceFunc) dummy_connect_complete, dev); + return id; +} + +unsigned int headset_suspend_stream(struct audio_device *dev, + headset_stream_cb_t cb, + void *user_data) +{ + struct headset *hs = dev->headset; + unsigned int id; + int sock; + + if (hs->state == HEADSET_STATE_DISCONNECTED || + hs->state == HEADSET_STATE_CONNECTING) + return 0; + + if (hs->dc_timer) { + g_source_remove(hs->dc_timer); + hs->dc_timer = 0; + } + + sock = g_io_channel_unix_get_fd(hs->sco); + + /* shutdown but leave the socket open and wait for hup */ + shutdown(sock, SHUT_RDWR); + + id = connect_cb_new(hs, HEADSET_STATE_CONNECTED, cb, user_data); + + return id; +} + +gboolean get_hfp_active(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + return hs->hfp_active; +} + +void set_hfp_active(struct audio_device *dev, gboolean active) +{ + struct headset *hs = dev->headset; + + hs->hfp_active = active; +} + +GIOChannel *headset_get_rfcomm(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + return hs->tmp_rfcomm; +} + +int headset_connect_rfcomm(struct audio_device *dev, GIOChannel *io) +{ + struct headset *hs = dev->headset; + + if (hs->tmp_rfcomm) + return -EALREADY; + + hs->tmp_rfcomm = g_io_channel_ref(io); + + return 0; +} + +int headset_connect_sco(struct audio_device *dev, GIOChannel *io) +{ + struct headset *hs = dev->headset; + struct headset_slc *slc = hs->slc; + + if (hs->sco) + return -EISCONN; + + hs->sco = g_io_channel_ref(io); + + if (slc->pending_ring) { + ring_timer_cb(NULL); + ag.ring_timer = g_timeout_add_seconds(RING_INTERVAL, + ring_timer_cb, + NULL); + slc->pending_ring = FALSE; + } + + return 0; +} + +void headset_set_state(struct audio_device *dev, headset_state_t state) +{ + struct headset *hs = dev->headset; + struct headset_slc *slc = hs->slc; + gboolean value; + const char *state_str; + headset_state_t old_state = hs->state; + GSList *l; + + if (old_state == state) + return; + + state_str = state2str(state); + + switch (state) { + case HEADSET_STATE_DISCONNECTED: + value = FALSE; + close_sco(dev); + headset_close_rfcomm(dev); + emit_property_changed(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, "State", + DBUS_TYPE_STRING, &state_str); + g_dbus_emit_signal(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, + "Disconnected", + DBUS_TYPE_INVALID); + if (hs->state > HEADSET_STATE_CONNECTING) { + emit_property_changed(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, "Connected", + DBUS_TYPE_BOOLEAN, &value); + telephony_device_disconnected(dev); + } + active_devices = g_slist_remove(active_devices, dev); + break; + case HEADSET_STATE_CONNECTING: + emit_property_changed(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, "State", + DBUS_TYPE_STRING, &state_str); + break; + case HEADSET_STATE_CONNECTED: + close_sco(dev); + if (hs->state != HEADSET_STATE_PLAY_IN_PROGRESS) + emit_property_changed(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, "State", + DBUS_TYPE_STRING, &state_str); + if (hs->state < state) { + if (ag.features & AG_FEATURE_INBAND_RINGTONE) + slc->inband_ring = TRUE; + else + slc->inband_ring = FALSE; + g_dbus_emit_signal(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, + "Connected", + DBUS_TYPE_INVALID); + value = TRUE; + emit_property_changed(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, + "Connected", + DBUS_TYPE_BOOLEAN, &value); + active_devices = g_slist_append(active_devices, dev); + telephony_device_connected(dev); + } else if (hs->state == HEADSET_STATE_PLAYING) { + value = FALSE; + g_dbus_emit_signal(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, + "Stopped", + DBUS_TYPE_INVALID); + emit_property_changed(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, + "Playing", + DBUS_TYPE_BOOLEAN, &value); + } + break; + case HEADSET_STATE_PLAY_IN_PROGRESS: + break; + case HEADSET_STATE_PLAYING: + value = TRUE; + emit_property_changed(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, "State", + DBUS_TYPE_STRING, &state_str); + hs->sco_id = g_io_add_watch(hs->sco, + G_IO_ERR | G_IO_HUP | G_IO_NVAL, + (GIOFunc) sco_cb, dev); + + g_dbus_emit_signal(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, "Playing", + DBUS_TYPE_INVALID); + emit_property_changed(dev->conn, dev->path, + AUDIO_HEADSET_INTERFACE, "Playing", + DBUS_TYPE_BOOLEAN, &value); + + if (slc->sp_gain >= 0) + headset_send(hs, "\r\n+VGS=%u\r\n", slc->sp_gain); + if (slc->mic_gain >= 0) + headset_send(hs, "\r\n+VGM=%u\r\n", slc->mic_gain); + break; + } + + hs->state = state; + + DBG("State changed %s: %s -> %s", dev->path, str_state[old_state], + str_state[state]); + + for (l = headset_callbacks; l != NULL; l = l->next) { + struct headset_state_callback *cb = l->data; + cb->cb(dev, old_state, state, cb->user_data); + } +} + +headset_state_t headset_get_state(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + return hs->state; +} + +int headset_get_channel(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + return hs->rfcomm_ch; +} + +gboolean headset_is_active(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + if (hs->state != HEADSET_STATE_DISCONNECTED) + return TRUE; + + return FALSE; +} + +headset_lock_t headset_get_lock(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + return hs->lock; +} + +gboolean headset_lock(struct audio_device *dev, headset_lock_t lock) +{ + struct headset *hs = dev->headset; + + if (hs->lock & lock) + return FALSE; + + hs->lock |= lock; + + return TRUE; +} + +gboolean headset_unlock(struct audio_device *dev, headset_lock_t lock) +{ + struct headset *hs = dev->headset; + + if (!(hs->lock & lock)) + return FALSE; + + hs->lock &= ~lock; + + if (hs->lock) + return TRUE; + + if (hs->state == HEADSET_STATE_PLAYING) + headset_set_state(dev, HEADSET_STATE_CONNECTED); + + if (hs->auto_dc) { + if (hs->state == HEADSET_STATE_CONNECTED) + hs->dc_timer = g_timeout_add_seconds(DC_TIMEOUT, + (GSourceFunc) hs_dc_timeout, + dev); + else + headset_set_state(dev, HEADSET_STATE_DISCONNECTED); + } + + return TRUE; +} + +gboolean headset_suspend(struct audio_device *dev, void *data) +{ + return TRUE; +} + +gboolean headset_play(struct audio_device *dev, void *data) +{ + return TRUE; +} + +int headset_get_sco_fd(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + if (!hs->sco) + return -1; + + return g_io_channel_unix_get_fd(hs->sco); +} + +gboolean headset_get_nrec(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + if (!hs->slc) + return TRUE; + + return hs->slc->nrec; +} + +unsigned int headset_add_nrec_cb(struct audio_device *dev, + headset_nrec_cb cb, void *user_data) +{ + struct headset *hs = dev->headset; + struct headset_nrec_callback *nrec_cb; + static unsigned int id = 0; + + nrec_cb = g_new(struct headset_nrec_callback, 1); + nrec_cb->cb = cb; + nrec_cb->user_data = user_data; + nrec_cb->id = ++id; + + hs->nrec_cbs = g_slist_prepend(hs->nrec_cbs, nrec_cb); + + return nrec_cb->id; +} + +gboolean headset_remove_nrec_cb(struct audio_device *dev, unsigned int id) +{ + struct headset *hs = dev->headset; + GSList *l; + + for (l = hs->nrec_cbs; l != NULL; l = l->next) { + struct headset_nrec_callback *cb = l->data; + if (cb && cb->id == id) { + hs->nrec_cbs = g_slist_remove(hs->nrec_cbs, cb); + g_free(cb); + return TRUE; + } + } + + return FALSE; +} + +gboolean headset_get_inband(struct audio_device *dev) +{ + struct headset *hs = dev->headset; + + if (!hs->slc) + return TRUE; + + return hs->slc->inband_ring; +} + +gboolean headset_get_sco_hci(struct audio_device *dev) +{ + return sco_hci; +} + +void headset_shutdown(struct audio_device *dev) +{ + struct pending_connect *p = dev->headset->pending; + + if (p && p->msg) + error_connect_failed(dev->conn, p->msg, ECANCELED); + + pending_connect_finalize(dev); + headset_set_state(dev, HEADSET_STATE_DISCONNECTED); +} + +int telephony_event_ind(int index) +{ + if (!active_devices) + return -ENODEV; + + if (!ag.er_ind) { + DBG("telephony_report_event called but events are disabled"); + return -EINVAL; + } + + send_foreach_headset(active_devices, hfp_cmp, + "\r\n+CIEV: %d,%d\r\n", index + 1, + ag.indicators[index].val); + + return 0; +} + +int telephony_response_and_hold_ind(int rh) +{ + if (!active_devices) + return -ENODEV; + + ag.rh = rh; + + /* If we aren't in any response and hold state don't send anything */ + if (ag.rh < 0) + return 0; + + send_foreach_headset(active_devices, hfp_cmp, "\r\n+BTRH: %d\r\n", + ag.rh); + + return 0; +} + +int telephony_incoming_call_ind(const char *number, int type) +{ + struct audio_device *dev; + struct headset *hs; + struct headset_slc *slc; + + if (fast_connectable) + manager_set_fast_connectable(TRUE); + + if (!active_devices) + return -ENODEV; + + /* Get the latest connected device */ + dev = active_devices->data; + hs = dev->headset; + slc = hs->slc; + + if (ag.ring_timer) { + DBG("telephony_incoming_call_ind: already calling"); + return -EBUSY; + } + + /* With HSP 1.2 the RING messages should *not* be sent if inband + * ringtone is being used */ + if (!hs->hfp_active && slc->inband_ring) + return 0; + + g_free(ag.number); + ag.number = g_strdup(number); + ag.number_type = type; + + if (slc->inband_ring && hs->hfp_active && + hs->state != HEADSET_STATE_PLAYING) { + slc->pending_ring = TRUE; + return 0; + } + + ring_timer_cb(NULL); + ag.ring_timer = g_timeout_add_seconds(RING_INTERVAL, ring_timer_cb, + NULL); + + return 0; +} + +int telephony_calling_stopped_ind(void) +{ + struct audio_device *dev; + + if (fast_connectable) + manager_set_fast_connectable(FALSE); + + if (ag.ring_timer) { + g_source_remove(ag.ring_timer); + ag.ring_timer = 0; + } + + if (!active_devices) + return 0; + + /* In case SCO isn't fully up yet */ + dev = active_devices->data; + + if (!dev->headset->slc->pending_ring && !ag.ring_timer) + return -EINVAL; + + dev->headset->slc->pending_ring = FALSE; + + return 0; +} + +int telephony_ready_ind(uint32_t features, + const struct indicator *indicators, int rh, + const char *chld) +{ + ag.telephony_ready = TRUE; + ag.features = features; + ag.indicators = indicators; + ag.rh = rh; + ag.chld = chld; + + DBG("Telephony plugin initialized"); + + print_ag_features(ag.features); + + return 0; +} + +int telephony_deinit(void) +{ + g_free(ag.number); + + memset(&ag, 0, sizeof(ag)); + + ag.er_mode = 3; + ag.rh = BTRH_NOT_SUPPORTED; + + DBG("Telephony deinitialized"); + + return 0; +} + +int telephony_list_current_call_ind(int idx, int dir, int status, int mode, + int mprty, const char *number, + int type) +{ + if (!active_devices) + return -ENODEV; + + if (number && strlen(number) > 0) + send_foreach_headset(active_devices, hfp_cmp, + "\r\n+CLCC: %d,%d,%d,%d,%d,\"%s\",%d\r\n", + idx, dir, status, mode, mprty, number, type); + else + send_foreach_headset(active_devices, hfp_cmp, + "\r\n+CLCC: %d,%d,%d,%d,%d\r\n", + idx, dir, status, mode, mprty); + + return 0; +} + +int telephony_subscriber_number_ind(const char *number, int type, int service) +{ + if (!active_devices) + return -ENODEV; + + send_foreach_headset(active_devices, hfp_cmp, + "\r\n+CNUM: ,%s,%d,,%d\r\n", + number, type, service); + + return 0; +} + +static int cwa_cmp(struct headset *hs) +{ + if (!hs->hfp_active) + return -1; + + if (hs->slc->cwa_enabled) + return 0; + else + return -1; +} + +int telephony_call_waiting_ind(const char *number, int type) +{ + if (!active_devices) + return -ENODEV; + + send_foreach_headset(active_devices, cwa_cmp, + "\r\n+CCWA: \"%s\",%d\r\n", + number, type); + + return 0; +} + +unsigned int headset_add_state_cb(headset_state_cb cb, void *user_data) +{ + struct headset_state_callback *state_cb; + static unsigned int id = 0; + + state_cb = g_new(struct headset_state_callback, 1); + state_cb->cb = cb; + state_cb->user_data = user_data; + state_cb->id = ++id; + + headset_callbacks = g_slist_append(headset_callbacks, state_cb); + + return state_cb->id; +} + +gboolean headset_remove_state_cb(unsigned int id) +{ + GSList *l; + + for (l = headset_callbacks; l != NULL; l = l->next) { + struct headset_state_callback *cb = l->data; + if (cb && cb->id == id) { + headset_callbacks = g_slist_remove(headset_callbacks, cb); + g_free(cb); + return TRUE; + } + } + + return FALSE; +} |