/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 2006-2007 Nokia Corporation
* Copyright (C) 2004-2008 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 <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
#include <bluetooth/sco.h>
#include <bluetooth/rfcomm.h>
#include <bluetooth/sdp.h>
#include <bluetooth/sdp_lib.h>
#include <glib.h>
#include <dbus/dbus.h>
#include <gdbus.h>
#include "logging.h"
#include "device.h"
#include "manager.h"
#include "error.h"
#include "headset.h"
#include "glib-helper.h"
#define DC_TIMEOUT 3000
#define RING_INTERVAL 3000
#define BUF_SIZE 1024
#define HEADSET_GAIN_SPEAKER 'S'
#define HEADSET_GAIN_MICROPHONE 'M'
#define AG_FEATURE_THREE_WAY_CALLING 0x0001
#define AG_FEATURE_EC_ANDOR_NR 0x0002
#define AG_FEATURE_VOICE_RECOGNITION 0x0004
#define AG_FEATURE_INBAND_RINGTONE 0x0008
#define AG_FEATURE_ATTACH_NUMBER_TO_VOICETAG 0x0010
#define AG_FEATURE_REJECT_A_CALL 0x0020
#define AG_FEATURE_ENHANCES_CALL_STATUS 0x0040
#define AG_FEATURE_ENHANCES_CALL_CONTROL 0x0080
#define AG_FEATURE_EXTENDED_ERROR_RESULT_CODES 0x0100
static uint32_t ag_features = 0;
static gboolean sco_hci = TRUE;
static char *str_state[] = {
"HEADSET_STATE_DISCONNECTED",
"HEADSET_STATE_CONNECT_IN_PROGRESS",
"HEADSET_STATE_CONNECTED",
"HEADSET_STATE_PLAY_IN_PROGRESS",
"HEADSET_STATE_PLAYING",
};
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;
};
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 ring_timer;
guint dc_timer;
char buf[BUF_SIZE];
int data_start;
int data_length;
gboolean hfp_active;
gboolean search_hfp;
gboolean cli_active;
char *ph_number;
int type;
headset_state_t state;
struct pending_connect *pending;
int sp_gain;
int mic_gain;
unsigned int hfp_features;
headset_lock_t lock;
};
struct event {
const char *cmd;
int (*callback) (struct audio_device *device, const char *buf);
};
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 int headset_send(struct headset *hs, char *format, ...)
{
char rsp[BUF_SIZE];
va_list ap;
ssize_t total_written, written, count;
int fd;
va_start(ap, format);
count = vsnprintf(rsp, sizeof(rsp), format, ap);
va_end(ap);
if (count < 0)
return -EINVAL;
if (!hs->rfcomm) {
error("headset_send: the headset is not connected");
return -EIO;
}
written = total_written = 0;
fd = g_io_channel_unix_get_fd(hs->rfcomm);
while (total_written < count) {
written = write(fd, rsp + total_written, count - total_written);
if (written < 0)
return -errno;
total_written += written;
}
return 0;
}
static int supported_features(struct audio_device *device, const char *buf)
{
struct headset *hs = device->headset;
int err;
if (strlen(buf) < 9)
return -EINVAL;
hs->hfp_features = strtoul(&buf[8], NULL, 10);
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 int report_indicators(struct audio_device *device, const char *buf)
{
struct headset *hs = device->headset;
int err;
if (buf[7] == '=')
err = headset_send(hs, "\r\n+CIND:(\"service\",(0,1)),"
"(\"call\",(0,1)),(\"callsetup\",(0-3))\r\n");
else
err = headset_send(hs, "\r\n+CIND:1,0,0\r\n");
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)
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;
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_close(p->io);
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);
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 sco_connect_cb(GIOChannel *chan, int err, const bdaddr_t *src,
const bdaddr_t *dst, gpointer user_data)
{
int sk;
struct audio_device *dev = user_data;
struct headset *hs = dev->headset;
struct pending_connect *p = hs->pending;
if (err < 0) {
error("connect(): %s (%d)", strerror(-err), -err);
if (p->msg)
error_connection_attempt_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;
}
debug("SCO socket opened for headset %s", dev->path);
sk = g_io_channel_unix_get_fd(chan);
info("SCO fd=%d", sk);
hs->sco = chan;
p->io = NULL;
if (p->msg) {
DBusMessage *reply = dbus_message_new_method_return(p->msg);
dbus_connection_send(dev->conn, reply, NULL);
dbus_message_unref(reply);
}
pending_connect_finalize(dev);
fcntl(sk, F_SETFL, 0);
headset_set_state(dev, HEADSET_STATE_PLAYING);
}
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;
int err;
if (hs->state != HEADSET_STATE_CONNECTED)
return -EINVAL;
err = bt_sco_connect(&dev->src, &dev->dst, sco_connect_cb, dev);
if (err < 0) {
error("connect: %s (%d)", strerror(-err), -err);
return -err;
}
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 void hfp_slc_complete(struct audio_device *dev)
{
struct headset *hs = dev->headset;
struct pending_connect *p = hs->pending;
debug("HFP Service Level Connection established");
headset_set_state(dev, HEADSET_STATE_CONNECTED);
if (p == NULL)
return;
if (p->msg) {
DBusMessage *reply = dbus_message_new_method_return(p->msg);
dbus_connection_send(dev->conn, reply, NULL);
dbus_message_unref(reply);
}
if (p->target_state == HEADSET_STATE_CONNECTED) {
pending_connect_finalize(dev);
return;
}
p->err = sco_connect(dev, NULL, NULL, NULL);
if (p->err < 0)
pending_connect_finalize(dev);
}
static int event_reporting(struct audio_device *dev, const char *buf)
{
struct headset *hs = dev->headset;
int ret;
ret = headset_send(hs, "\r\nOK\r\n");
if (ret < 0)
return ret;
if (hs->state != HEADSET_STATE_CONNECT_IN_PROGRESS)
return 0;
if (ag_features & AG_FEATURE_THREE_WAY_CALLING)
return 0;
hfp_slc_complete(dev);
return 0;
}
static int call_hold(struct audio_device *dev, const char *buf)
{
struct headset *hs = dev->headset;
int err;
err = headset_send(hs, "\r\n+CHLD:(0,1,1x,2,2x,3,4)\r\n");
if (err < 0)
return err;
err = headset_send(hs, "\r\nOK\r\n");
if (err < 0)
return err;
if (hs->state != HEADSET_STATE_CONNECT_IN_PROGRESS)
return 0;
hfp_slc_complete(dev);
return 0;
}
static int answer_call(struct audio_device *device, const char *buf)
{
struct headset *hs = device->headset;
int err;
g_dbus_emit_signal(device->conn, device->path,
AUDIO_HEADSET_INTERFACE, "AnswerRequested",
DBUS_TYPE_INVALID);
if (hs->ring_timer) {
g_source_remove(hs->ring_timer);
hs->ring_timer = 0;
}
if (!hs->hfp_active)
return headset_send(hs, "\r\nOK\r\n");
if (hs->ph_number) {
g_free(hs->ph_number);
hs->ph_number = NULL;
}
err = headset_send(hs, "\r\nOK\r\n");
if (err < 0)
return err;
/*+CIEV: (call = 1)*/
err = headset_send(hs, "\r\n+CIEV:2,1\r\n");
if (err < 0)
return err;
/*+CIEV: (callsetup = 0)*/
return headset_send(hs, "\r\n+CIEV:3,0\r\n");
}
static int terminate_call(struct audio_device *device, const char *buf)
{
struct headset *hs = device->headset;
int err;
g_dbus_emit_signal(device->conn, device->path,
AUDIO_HEADSET_INTERFACE, "CallTerminated",
DBUS_TYPE_INVALID);
err = headset_send(hs, "\r\nOK\r\n");
if (err < 0)
return err;
if (hs->ph_number) {
g_free(hs->ph_number);
hs->ph_number = NULL;
}
if (hs->ring_timer) {
g_source_remove(hs->ring_timer);
hs->ring_timer = 0;
/*+CIEV: (callsetup = 0)*/
return headset_send(hs, "\r\n+CIEV:3,0\r\n");
}
/*+CIEV: (call = 0)*/
return headset_send(hs, "\r\n+CIEV:2,0\r\n");
}
static int cli_notification(struct audio_device *device, const char *buf)
{
struct headset *hs = device->headset;
if (strlen(buf) < 9)
return -EINVAL;
hs->cli_active = buf[8] == '1' ? TRUE : FALSE;
return headset_send(hs, "\r\nOK\r\n");
}
static int signal_gain_setting(struct audio_device *device, const char *buf)
{
struct headset *hs = device->headset;
const char *name;
dbus_uint16_t gain;
if (strlen(buf) < 8) {
error("Too short string for Gain setting");
return -EINVAL;
}
gain = (dbus_uint16_t) strtol(&buf[7], NULL, 10);
if (gain > 15) {
error("Invalid gain value received: %u", gain);
return -EINVAL;
}
switch (buf[5]) {
case HEADSET_GAIN_SPEAKER:
if (hs->sp_gain == gain)
goto ok;
name = "SpeakerGainChanged";
hs->sp_gain = gain;
break;
case HEADSET_GAIN_MICROPHONE:
if (hs->mic_gain == gain)
goto ok;
name = "MicrophoneGainChanged";
hs->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);
ok:
return headset_send(hs, "\r\nOK\r\n");
}
static struct event event_callbacks[] = {
{ "ATA", answer_call },
{ "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", answer_call },
{ "AT+CLIP", cli_notification },
{ 0 }
};
static int handle_event(struct audio_device *device, const char *buf)
{
struct event *ev;
debug("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) {
g_source_remove(hs->sco_id);
hs->sco_id = 0;
g_io_channel_close(hs->sco);
g_io_channel_unref(hs->sco);
hs->sco = NULL;
}
}
static gboolean rfcomm_io_cb(GIOChannel *chan, GIOCondition cond,
struct audio_device *device)
{
struct headset *hs;
unsigned char buf[BUF_SIZE];
char *cr;
gsize bytes_read = 0;
gsize free_space;
int err;
off_t cmd_len;
if (cond & G_IO_NVAL)
return FALSE;
hs = device->headset;
if (cond & (G_IO_ERR | G_IO_HUP))
goto failed;
if (g_io_channel_read(chan, (gchar *) buf, sizeof(buf) - 1,
&bytes_read) != G_IO_ERROR_NONE)
return TRUE;
free_space = sizeof(hs->buf) - hs->data_start - hs->data_length - 1;
if (free_space < 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(&hs->buf[hs->data_start], buf, bytes_read);
hs->data_length += bytes_read;
/* Make sure the data is null terminated so we can use string
* functions */
hs->buf[hs->data_start + hs->data_length] = '\0';
cr = strchr(&hs->buf[hs->data_start], '\r');
if (!cr)
return TRUE;
cmd_len = 1 + (off_t) cr - (off_t) &hs->buf[hs->data_start];
*cr = '\0';
err = handle_event(device, &hs->buf[hs->data_start]);
if (err == -EINVAL) {
error("Badly formated or unrecognized command: %s",
&hs->buf[hs->data_start]);
err = headset_send(hs, "\r\nERROR\r\n");
} else if (err < 0)
error("Error handling command %s: %s (%d)",
&hs->buf[hs->data_start], strerror(-err), -err);
hs->data_start += cmd_len;
hs->data_length -= cmd_len;
if (!hs->data_length)
hs->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)
{
struct headset *hs;
if (cond & G_IO_NVAL)
return FALSE;
hs = device->headset;
error("Audio connection got disconnected");
headset_set_state(device, HEADSET_STATE_CONNECTED);
return FALSE;
}
static void rfcomm_connect_cb(GIOChannel *chan, int err, const bdaddr_t *src,
const bdaddr_t *dst, 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 < 0) {
error("connect(): %s (%d)", strerror(-err), -err);
goto failed;
}
ba2str(&dev->dst, hs_address);
hs->rfcomm = chan;
p->io = NULL;
if (server_is_enabled(HANDSFREE_SVCLASS_ID) && hs->hfp_handle != 0)
hs->hfp_active = TRUE;
else
hs->hfp_active = FALSE;
g_io_add_watch(chan, G_IO_IN | G_IO_ERR | G_IO_HUP| G_IO_NVAL,
(GIOFunc) rfcomm_io_cb, dev);
debug("%s: Connected to %s", dev->path, hs_address);
/* In HFP mode wait for Service Level Connection */
if (hs->hfp_active)
return;
headset_set_state(dev, HEADSET_STATE_CONNECTED);
if (p->target_state == HEADSET_STATE_PLAYING) {
p->err = sco_connect(dev, NULL, NULL, NULL);
if (p->err < 0)
goto failed;
return;
}
if (p->msg) {
DBusMessage *reply = dbus_message_new_method_return(p->msg);
dbus_connection_send(dev->conn, reply, NULL);
dbus_message_unref(reply);
}
pending_connect_finalize(dev);
return;
failed:
if (p->msg)
error_connection_attempt_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 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;
int ch = -1;
sdp_record_t *record = NULL;
sdp_list_t *protos, *classes = NULL;
uuid_t uuid;
if (err < 0) {
error("Unable to get service record: %s (%d)", strerror(-err),
-err);
goto failed_not_supported;
}
if (!recs || !recs->data) {
error("No records found");
goto failed_not_supported;
}
record = recs->data;
if (sdp_get_service_classes(record, &classes) < 0) {
error("Unable to get service classes from record");
goto failed_not_supported;
}
memcpy(&uuid, classes->data, sizeof(uuid));
if (!sdp_uuid128_to_uuid(&uuid) || uuid.type != SDP_UUID16) {
error("Not a 16 bit UUID");
goto failed_not_supported;
}
if (hs->search_hfp) {
if (uuid.value.uuid16 != HANDSFREE_SVCLASS_ID) {
error("Service record didn't contain the HFP UUID");
goto failed_not_supported;
}
hs->hfp_handle = record->handle;
} else {
if (uuid.value.uuid16 != HEADSET_SVCLASS_ID) {
error("Service record didn't contain the HSP UUID");
goto failed_not_supported;
}
hs->hsp_handle = record->handle;
}
if (!sdp_get_access_protos(record, &protos)) {
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);
protos = NULL;
}
if (ch == -1) {
error("Unable to extract RFCOMM channel from service record");
goto failed_not_supported;
}
hs->rfcomm_ch = ch;
err = rfcomm_connect(dev, NULL, NULL, NULL);
if (err < 0) {
error("Unable to connect: %s (%s)", strerror(-err), -err);
p->err = -err;
error_connection_attempt_failed(dev->conn, p->msg, p->err);
goto failed;
}
sdp_list_free(classes, free);
sdp_record_free(record);
return;
failed_not_supported:
if (p->msg) {
error_not_supported(dev->conn, p->msg);
dbus_message_unref(p->msg);
p->msg = NULL;
}
failed:
if (classes)
sdp_list_free(classes, free);
if (record)
sdp_record_free(record);
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;
uuid_t uuid;
sdp_uuid16_create(&uuid, hs->search_hfp ? HANDSFREE_SVCLASS_ID :
HEADSET_SVCLASS_ID);
headset_set_state(device, HEADSET_STATE_CONNECT_IN_PROGRESS);
pending_connect_init(hs, HEADSET_STATE_CONNECTED);
if (cb) {
unsigned int id;
id = connect_cb_new(hs, HEADSET_STATE_CONNECTED,
cb, user_data);
if (cb_id)
*cb_id = id;
}
return bt_search_service(&device->src, &device->dst, &uuid,
get_record_cb, device, NULL);
}
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];
int err;
if (hs->rfcomm_ch < 0)
return get_records(dev, cb, user_data, cb_id);
ba2str(&dev->dst, address);
debug("%s: Connecting to %s channel %d", dev->path, address,
hs->rfcomm_ch);
err = bt_rfcomm_connect(&dev->src, &dev->dst, hs->rfcomm_ch,
rfcomm_connect_cb, dev);
if (err < 0) {
error("connect() failed: %s (%d)", strerror(-err), -err);
return err;
}
headset_set_state(dev, HEADSET_STATE_CONNECT_IN_PROGRESS);
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 g_dbus_create_error(msg, ERROR_INTERFACE
".NotConnected",
"Device not Connected");
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;
DBusMessage *reply = NULL;
char hs_address[18];
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
if (hs->state == HEADSET_STATE_DISCONNECTED)
return g_dbus_create_error(msg, ERROR_INTERFACE
".NotConnected",
"Device not Connected");
headset_set_state(device, HEADSET_STATE_DISCONNECTED);
ba2str(&device->dst, hs_address);
info("Disconnected from %s, %s", hs_address, device->path);
return reply;
}
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_CONNECT_IN_PROGRESS)
return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress",
"Connect in Progress");
else if (hs->state > HEADSET_STATE_CONNECT_IN_PROGRESS)
return g_dbus_create_error(msg, ERROR_INTERFACE
".AlreadyConnected",
"Already Connected");
err = rfcomm_connect(device, NULL, NULL, NULL);
if (err < 0)
return g_dbus_create_error(msg, ERROR_INTERFACE
".ConnectAttemptFailed",
"Connect Attempt Failed");
hs->auto_dc = FALSE;
hs->pending->msg = dbus_message_ref(msg);
return NULL;
}
static gboolean ring_timer_cb(gpointer data)
{
struct audio_device *device = data;
struct headset *hs = device->headset;
int err;
err = headset_send(hs, "\r\nRING\r\n");
if (err < 0)
error("Error while sending RING: %s (%d)",
strerror(-err), -err);
if (hs->cli_active && hs->ph_number) {
err = headset_send(hs, "\r\n+CLIP:\"%s\",%d\r\n",
hs->ph_number, hs->type);
if (err < 0)
error("Error while sending CLIP: %s (%d)",
strerror(-err), -err);
}
return TRUE;
}
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 g_dbus_create_error(msg, ERROR_INTERFACE
".NotConnected",
"Device not Connected");
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
if (hs->ring_timer) {
debug("IndicateCall received when already indicating");
goto done;
}
err = headset_send(hs, "\r\nRING\r\n");
if (err < 0) {
dbus_message_unref(reply);
return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
"%s", strerror(-err));
}
if (hs->cli_active && hs->ph_number) {
err = headset_send(hs, "\r\n+CLIP:\"%s\",%d\r\n",
hs->ph_number, hs->type);
if (err < 0) {
dbus_message_unref(reply);
return g_dbus_create_error(msg, ERROR_INTERFACE
".Failed", "%s",
strerror(-err));
}
}
hs->ring_timer = g_timeout_add(RING_INTERVAL, ring_timer_cb, device);
done:
return reply;
}
static DBusMessage *hs_cancel_ringing(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 g_dbus_create_error(msg, ERROR_INTERFACE
".NotConnected",
"Device not Connected");
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
if (!hs->ring_timer) {
debug("Got CancelRinging method call but ringing is not in progress");
goto done;
}
g_source_remove(hs->ring_timer);
hs->ring_timer = 0;
done:
if (hs->hfp_active) {
int err;
/*+CIEV: (callsetup = 0)*/
err = headset_send(hs, "\r\n+CIEV:3,0\r\n");
if (err < 0) {
dbus_message_unref(reply);
return g_dbus_create_error(msg, ERROR_INTERFACE
".Failed", "%s",
strerror(-err));
}
}
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 g_dbus_create_error(msg, ERROR_INTERFACE ".NotAvailable",
"Operation not Available");
}
switch (hs->state) {
case HEADSET_STATE_DISCONNECTED:
case HEADSET_STATE_CONNECT_IN_PROGRESS:
return g_dbus_create_error(msg, ERROR_INTERFACE
".NotConnected",
"Device not Connected");
case HEADSET_STATE_PLAY_IN_PROGRESS:
return g_dbus_create_error(msg, ERROR_INTERFACE
".InProgress",
"Play in Progress");
case HEADSET_STATE_PLAYING:
return g_dbus_create_error(msg, ERROR_INTERFACE
".AlreadyConnected",
"Device Already Connected");
case HEADSET_STATE_CONNECTED:
default:
break;
}
err = sco_connect(device, NULL, NULL, NULL);
if (err < 0)
return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
"%s", 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;
DBusMessage *reply;
dbus_uint16_t gain;
if (hs->state < HEADSET_STATE_CONNECTED || hs->sp_gain < 0)
return g_dbus_create_error(msg, ERROR_INTERFACE ".NotAvailable",
"Operation not Available");
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
gain = (dbus_uint16_t) hs->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;
DBusMessage *reply;
dbus_uint16_t gain;
if (hs->state < HEADSET_STATE_CONNECTED || hs->mic_gain < 0)
return g_dbus_create_error(msg, ERROR_INTERFACE ".NotAvailable",
"Operation not Available");
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
gain = (dbus_uint16_t) hs->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, char type)
{
struct audio_device *device = data;
struct headset *hs = device->headset;
DBusMessage *reply;
dbus_uint16_t gain;
int err;
if (hs->state < HEADSET_STATE_CONNECTED)
return g_dbus_create_error(msg, ERROR_INTERFACE
".NotConnected",
"Device not Connected");
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_UINT16, &gain,
DBUS_TYPE_INVALID))
return NULL;
if (gain > 15)
return g_dbus_create_error(msg, ERROR_INTERFACE
".InvalidArgument",
"Must be less than or equal to 15");
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
if (hs->state != HEADSET_STATE_PLAYING)
goto done;
err = headset_send(hs, "\r\n+VG%c=%u\r\n", type, gain);
if (err < 0) {
dbus_message_unref(reply);
return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
"%s", strerror(-err));
}
done:
if (type == HEADSET_GAIN_SPEAKER) {
hs->sp_gain = gain;
g_dbus_emit_signal(conn, device->path,
AUDIO_HEADSET_INTERFACE,
"SpeakerGainChanged",
DBUS_TYPE_UINT16, &gain,
DBUS_TYPE_INVALID);
} else {
hs->mic_gain = gain;
g_dbus_emit_signal(conn, device->path,
AUDIO_HEADSET_INTERFACE,
"MicrophoneGainChanged",
DBUS_TYPE_UINT16, &gain,
DBUS_TYPE_INVALID);
}
return reply;
}
static DBusMessage *hs_set_speaker_gain(DBusConnection *conn,
DBusMessage *msg,
void *data)
{
return hs_set_gain(conn, msg, data, HEADSET_GAIN_SPEAKER);
}
static DBusMessage *hs_set_mic_gain(DBusConnection *conn,
DBusMessage *msg,
void *data)
{
return hs_set_gain(conn, msg, data, HEADSET_GAIN_MICROPHONE);
}
static DBusMessage *hf_setup_call(DBusConnection *conn,
DBusMessage *msg,
void *data)
{
struct audio_device *device = data;
struct headset *hs = device->headset;
DBusMessage *reply;
const char *value;
int err;
if (!hs->hfp_active)
return g_dbus_create_error(msg, ERROR_INTERFACE
".NotSuppported",
"Not Supported");
if (hs->state < HEADSET_STATE_CONNECTED)
return g_dbus_create_error(msg, ERROR_INTERFACE
".NotConnected",
"Device not Connected");
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &value,
DBUS_TYPE_INVALID))
return NULL;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
if (!strncmp(value, "incoming", 8))
err = headset_send(hs, "\r\n+CIEV:3,1\r\n");
else if (!strncmp(value, "outgoing", 8))
err = headset_send(hs, "\r\n+CIEV:3,2\r\n");
else if (!strncmp(value, "remote", 6))
err = headset_send(hs, "\r\n+CIEV:3,3\r\n");
else
err = -EINVAL;
if (err < 0) {
dbus_message_unref(reply);
return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
"%s", strerror(-err));
}
return reply;
}
static DBusMessage *hf_identify_call(DBusConnection *conn,
DBusMessage *msg,
void *data)
{
struct audio_device *device = data;
struct headset *hs = device->headset;
DBusMessage *reply;
const char *number;
dbus_int32_t type;
if (!hs->hfp_active && !hs->cli_active)
return g_dbus_create_error(msg, ERROR_INTERFACE
".NotSuppported",
"Not Supported");
if (hs->state < HEADSET_STATE_CONNECTED)
return g_dbus_create_error(msg, ERROR_INTERFACE
".NotConnected",
"Device not Connected");
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &number,
DBUS_TYPE_INT32, &type, DBUS_TYPE_INVALID))
return NULL;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
g_free(hs->ph_number);
hs->ph_number = g_strdup(number);
hs->type = type;
return reply;
}
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_ringing },
{ "Play", "", "", hs_play,
G_DBUS_METHOD_FLAG_ASYNC },
{ "Stop", "", "", hs_stop },
{ "IsPlaying", "", "b", hs_is_playing },
{ "GetSpeakerGain", "", "q", hs_get_speaker_gain },
{ "GetMicrophoneGain", "", "q", hs_get_mic_gain },
{ "SetSpeakerGain", "q", "", hs_set_speaker_gain },
{ "SetMicrophoneGain", "q", "", hs_set_mic_gain },
{ "SetupCall", "s", "", hf_setup_call },
{ "IdentifyCall", "si", "", hf_identify_call },
{ NULL, NULL, NULL, NULL }
};
static GDBusSignalTable headset_signals[] = {
{ "Connected", "" },
{ "Disconnected", "" },
{ "AnswerRequested", "" },
{ "Stopped", "" },
{ "Playing", "" },
{ "SpeakerGainChanged", "q" },
{ "MicrophoneGainChanged", "q" },
{ "CallTerminated", "" },
{ NULL, NULL }
};
static void headset_set_channel(struct headset *headset, 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;
}
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) {
headset->rfcomm_ch = ch;
debug("Discovered %s service on RFCOMM channel %d",
svc == HEADSET_SVCLASS_ID ? "Headset" : "Handsfree",
ch);
} else
error("Unable to get RFCOMM channel from Headset record");
}
void headset_update(struct audio_device *dev, sdp_record_t *record, uint16_t svc)
{
struct headset *headset = dev->headset;
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:
debug("Invalid record passed to headset_update");
return;
}
headset_set_channel(headset, record, svc);
}
struct headset *headset_init(struct audio_device *dev, sdp_record_t *record,
uint16_t svc)
{
struct headset *hs;
hs = g_new0(struct headset, 1);
hs->rfcomm_ch = -1;
hs->sp_gain = -1;
hs->mic_gain = -1;
hs->search_hfp = server_is_enabled(HANDSFREE_SVCLASS_ID);
hs->hfp_active = FALSE;
hs->cli_active = FALSE;
hs->ph_number = NULL;
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:
debug("Invalid record passed to headset_init");
g_free(hs);
return NULL;
}
headset_set_channel(hs, record, svc);
register_iface:
if (!g_dbus_register_interface(dev->conn, dev->path,
AUDIO_HEADSET_INTERFACE,
headset_methods, headset_signals, NULL,
dev, NULL)) {
g_free(hs);
return NULL;
}
return hs;
}
uint32_t headset_config_init(GKeyFile *config)
{
GError *err = NULL;
gboolean value;
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) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} 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);
}
value = g_key_file_get_boolean(config, "Headset", "3WayCalling",
&err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_THREE_WAY_CALLING;
value = g_key_file_get_boolean(config, "Headset", "EchoCancelNoiseCancel",
&err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_EC_ANDOR_NR;
value = g_key_file_get_boolean(config, "Headset", "VoiceRecognition",
&err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_VOICE_RECOGNITION;
value = g_key_file_get_boolean(config, "Headset", "InBandRingtone",
&err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_INBAND_RINGTONE;
value = g_key_file_get_boolean(config, "Headset", "VoiceTags",
&err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_ATTACH_NUMBER_TO_VOICETAG;
value = g_key_file_get_boolean(config, "Headset", "RejectingCalls",
&err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_REJECT_A_CALL;
value = g_key_file_get_boolean(config, "Headset", "EnhancedCallStatus",
&err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_ENHANCES_CALL_STATUS;
value = g_key_file_get_boolean(config, "Headset", "EnhancedCallControl",
&err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_ENHANCES_CALL_CONTROL;
value = g_key_file_get_boolean(config, "Headset",
"ExtendedErrorResultCodes", &err);
if (err) {
debug("audio.conf: %s", err->message);
g_error_free(err);
err = NULL;
} else if (value)
ag_features |= AG_FEATURE_EXTENDED_ERROR_RESULT_CODES;
return ag_features;
}
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;
}
if (hs->sco) {
g_io_channel_close(hs->sco);
g_io_channel_unref(hs->sco);
}
if (hs->rfcomm) {
g_io_channel_close(hs->rfcomm);
g_io_channel_unref(hs->rfcomm);
}
g_free(hs);
dev->headset = NULL;
}
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;
pending_connect_finalize(dev);
if (hs->auto_dc) {
if (hs->rfcomm)
hs->dc_timer = g_timeout_add(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->rfcomm && hs->sco) {
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_CONNECT_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;
}
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;
}
int headset_connect_rfcomm(struct audio_device *dev, GIOChannel *io)
{
struct headset *hs = dev->headset;
hs->tmp_rfcomm = io;
return hs->tmp_rfcomm ? 0 : -EINVAL;
}
int headset_close_rfcomm(struct audio_device *dev)
{
struct headset *hs = dev->headset;
GIOChannel *rfcomm = hs->tmp_rfcomm ? hs->tmp_rfcomm : hs->rfcomm;
if (hs->ring_timer) {
g_source_remove(hs->ring_timer);
hs->ring_timer = 0;
}
if (rfcomm) {
g_io_channel_close(rfcomm);
g_io_channel_unref(rfcomm);
hs->tmp_rfcomm = NULL;
hs->rfcomm = NULL;
}
hs->data_start = 0;
hs->data_length = 0;
return 0;
}
void headset_set_authorized(struct audio_device *dev)
{
struct headset *hs = dev->headset;
hs->rfcomm = hs->tmp_rfcomm;
hs->tmp_rfcomm = NULL;
g_io_add_watch(hs->rfcomm,
G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
(GIOFunc) rfcomm_io_cb, dev);
hs->auto_dc = FALSE;
if (!hs->hfp_active)
headset_set_state(dev, HEADSET_STATE_CONNECTED);
}
void headset_set_state(struct audio_device *dev, headset_state_t state)
{
struct headset *hs = dev->headset;
if (hs->state == state)
return;
switch (state) {
case HEADSET_STATE_DISCONNECTED:
close_sco(dev);
headset_close_rfcomm(dev);
g_dbus_emit_signal(dev->conn, dev->path,
AUDIO_HEADSET_INTERFACE,
"Disconnected",
DBUS_TYPE_INVALID);
break;
case HEADSET_STATE_CONNECT_IN_PROGRESS:
break;
case HEADSET_STATE_CONNECTED:
close_sco(dev);
if (hs->state < state) {
g_dbus_emit_signal(dev->conn, dev->path,
AUDIO_HEADSET_INTERFACE,
"Connected",
DBUS_TYPE_INVALID);
} else if (hs->state == HEADSET_STATE_PLAYING) {
g_dbus_emit_signal(dev->conn, dev->path,
AUDIO_HEADSET_INTERFACE,
"Stopped",
DBUS_TYPE_INVALID);
}
break;
case HEADSET_STATE_PLAY_IN_PROGRESS:
break;
case HEADSET_STATE_PLAYING:
if (hs->sco_id)
g_source_remove(hs->sco_id);
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);
if (hs->sp_gain >= 0)
headset_send(hs, "\r\n+VGS=%u\r\n", hs->sp_gain);
if (hs->mic_gain >= 0)
headset_send(hs, "\r\n+VGM=%u\r\n", hs->mic_gain);
break;
}
debug("State changed %s: %s -> %s", dev->path, str_state[hs->state],
str_state[state]);
hs->state = state;
}
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;
}
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(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);
}