mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-10-29 05:40:27 -04:00
2903 lines
86 KiB
C
2903 lines
86 KiB
C
/* Spa HSP/HFP native backend */
|
|
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
|
|
/* SPDX-FileCopyrightText: Copyright © 2021 Collabora */
|
|
/* SPDX-License-Identifier: MIT */
|
|
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <stdarg.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <poll.h>
|
|
|
|
#include <bluetooth/bluetooth.h>
|
|
#include <bluetooth/sco.h>
|
|
|
|
#include <dbus/dbus.h>
|
|
|
|
#include <spa/debug/mem.h>
|
|
#include <spa/debug/log.h>
|
|
#include <spa/support/log.h>
|
|
#include <spa/support/loop.h>
|
|
#include <spa/support/dbus.h>
|
|
#include <spa/support/plugin.h>
|
|
#include <spa/utils/string.h>
|
|
#include <spa/utils/type.h>
|
|
#include <spa/utils/json.h>
|
|
#include <spa/param/audio/raw.h>
|
|
|
|
#include "defs.h"
|
|
|
|
#ifdef HAVE_LIBUSB
|
|
#include <libusb.h>
|
|
#endif
|
|
|
|
#include "dbus-helpers.h"
|
|
#include "modemmanager.h"
|
|
#include "upower.h"
|
|
|
|
static struct spa_log_topic log_topic = SPA_LOG_TOPIC(0, "spa.bluez5.native");
|
|
#undef SPA_LOG_TOPIC_DEFAULT
|
|
#define SPA_LOG_TOPIC_DEFAULT &log_topic
|
|
|
|
#define PROP_KEY_ROLES "bluez5.roles"
|
|
#define PROP_KEY_HEADSET_ROLES "bluez5.headset-roles"
|
|
|
|
#define HFP_CODEC_SWITCH_INITIAL_TIMEOUT_MSEC 5000
|
|
#define HFP_CODEC_SWITCH_TIMEOUT_MSEC 20000
|
|
|
|
#define INTERNATIONAL_NUMBER 145
|
|
#define NATIONAL_NUMBER 129
|
|
|
|
#define MAX_HF_INDICATORS 16
|
|
|
|
enum {
|
|
HFP_AG_INITIAL_CODEC_SETUP_NONE = 0,
|
|
HFP_AG_INITIAL_CODEC_SETUP_SEND,
|
|
HFP_AG_INITIAL_CODEC_SETUP_WAIT
|
|
};
|
|
|
|
#define CIND_INDICATORS "(\"service\",(0-1)),(\"call\",(0-1)),(\"callsetup\",(0-3)),(\"callheld\",(0-2)),(\"signal\",(0-5)),(\"roam\",(0-1)),(\"battchg\",(0-5))"
|
|
enum {
|
|
CIND_SERVICE = 1,
|
|
CIND_CALL,
|
|
CIND_CALLSETUP,
|
|
CIND_CALLHELD,
|
|
CIND_SIGNAL,
|
|
CIND_ROAM,
|
|
CIND_BATTERY_LEVEL,
|
|
CIND_MAX
|
|
};
|
|
|
|
struct modem {
|
|
bool network_has_service;
|
|
unsigned int signal_strength;
|
|
bool network_is_roaming;
|
|
char *operator_name;
|
|
char *own_number;
|
|
bool active_call;
|
|
unsigned int call_setup;
|
|
};
|
|
|
|
struct impl {
|
|
struct spa_bt_backend this;
|
|
|
|
struct spa_bt_monitor *monitor;
|
|
|
|
struct spa_log *log;
|
|
struct spa_loop *main_loop;
|
|
struct spa_system *main_system;
|
|
struct spa_loop_utils *loop_utils;
|
|
struct spa_dbus *dbus;
|
|
DBusConnection *conn;
|
|
|
|
#define DEFAULT_ENABLED_PROFILES (SPA_BT_PROFILE_HFP_HF | SPA_BT_PROFILE_HFP_AG)
|
|
enum spa_bt_profile enabled_profiles;
|
|
|
|
struct spa_source sco;
|
|
|
|
const struct spa_bt_quirks *quirks;
|
|
|
|
struct spa_list rfcomm_list;
|
|
unsigned int defer_setup_enabled:1;
|
|
|
|
struct modem modem;
|
|
unsigned int battery_level;
|
|
|
|
void *modemmanager;
|
|
struct spa_source *ring_timer;
|
|
void *upower;
|
|
};
|
|
|
|
struct transport_data {
|
|
struct rfcomm *rfcomm;
|
|
struct spa_source sco;
|
|
int err;
|
|
bool requesting;
|
|
};
|
|
|
|
enum hfp_hf_state {
|
|
hfp_hf_brsf,
|
|
hfp_hf_bac,
|
|
hfp_hf_cind1,
|
|
hfp_hf_cind2,
|
|
hfp_hf_cmer,
|
|
hfp_hf_slc1,
|
|
hfp_hf_slc2,
|
|
hfp_hf_vgs,
|
|
hfp_hf_vgm,
|
|
hfp_hf_bcs
|
|
};
|
|
|
|
enum hsp_hs_state {
|
|
hsp_hs_init1,
|
|
hsp_hs_init2,
|
|
hsp_hs_vgs,
|
|
hsp_hs_vgm,
|
|
};
|
|
|
|
struct rfcomm_volume {
|
|
bool active;
|
|
int hw_volume;
|
|
};
|
|
|
|
struct rfcomm {
|
|
struct spa_list link;
|
|
struct spa_source source;
|
|
struct impl *backend;
|
|
struct spa_bt_device *device;
|
|
struct spa_hook device_listener;
|
|
struct spa_bt_transport *transport;
|
|
struct spa_hook transport_listener;
|
|
enum spa_bt_profile profile;
|
|
struct spa_source timer;
|
|
struct spa_source *volume_sync_timer;
|
|
char* path;
|
|
bool has_volume;
|
|
struct rfcomm_volume volumes[SPA_BT_VOLUME_ID_TERM];
|
|
unsigned int broken_mic_hw_volume:1;
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
unsigned int slc_configured:1;
|
|
unsigned int codec_negotiation_supported:1;
|
|
unsigned int msbc_supported_by_hfp:1;
|
|
unsigned int hfp_ag_switching_codec:1;
|
|
unsigned int hfp_ag_initial_codec_setup:2;
|
|
unsigned int cind_call_active:1;
|
|
unsigned int cind_call_notify:1;
|
|
unsigned int extended_error_reporting:1;
|
|
unsigned int clip_notify:1;
|
|
enum hfp_hf_state hf_state;
|
|
enum hsp_hs_state hs_state;
|
|
unsigned int codec;
|
|
uint32_t cind_enabled_indicators;
|
|
char *hf_indicators[MAX_HF_INDICATORS];
|
|
#endif
|
|
};
|
|
|
|
static DBusHandlerResult profile_release(DBusConnection *conn, DBusMessage *m, void *userdata)
|
|
{
|
|
if (!reply_with_error(conn, m, BLUEZ_PROFILE_INTERFACE ".Error.NotImplemented", "Method not implemented"))
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
|
|
static void transport_destroy(void *data)
|
|
{
|
|
struct rfcomm *rfcomm = data;
|
|
struct impl *backend = rfcomm->backend;
|
|
|
|
spa_log_debug(backend->log, "transport %p destroy", rfcomm->transport);
|
|
rfcomm->transport = NULL;
|
|
}
|
|
|
|
static const struct spa_bt_transport_events transport_events = {
|
|
SPA_VERSION_BT_TRANSPORT_EVENTS,
|
|
.destroy = transport_destroy,
|
|
};
|
|
|
|
static const struct spa_bt_transport_implementation sco_transport_impl;
|
|
|
|
static struct spa_bt_transport *_transport_create(struct rfcomm *rfcomm)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
struct spa_bt_transport *t = NULL;
|
|
struct transport_data *td;
|
|
char* pathfd;
|
|
|
|
if ((pathfd = spa_aprintf("%s/fd%d", rfcomm->path, rfcomm->source.fd)) == NULL)
|
|
return NULL;
|
|
|
|
t = spa_bt_transport_create(backend->monitor, pathfd, sizeof(struct transport_data));
|
|
if (t == NULL) {
|
|
free(pathfd);
|
|
return NULL;
|
|
}
|
|
spa_bt_transport_set_implementation(t, &sco_transport_impl, t);
|
|
|
|
t->device = rfcomm->device;
|
|
spa_list_append(&t->device->transport_list, &t->device_link);
|
|
t->profile = rfcomm->profile;
|
|
t->backend = &backend->this;
|
|
t->n_channels = 1;
|
|
t->channels[0] = SPA_AUDIO_CHANNEL_MONO;
|
|
|
|
td = t->user_data;
|
|
td->rfcomm = rfcomm;
|
|
|
|
if (t->profile & SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY) {
|
|
t->volumes[SPA_BT_VOLUME_ID_RX].volume = DEFAULT_AG_VOLUME;
|
|
t->volumes[SPA_BT_VOLUME_ID_TX].volume = DEFAULT_AG_VOLUME;
|
|
} else {
|
|
t->volumes[SPA_BT_VOLUME_ID_RX].volume = DEFAULT_RX_VOLUME;
|
|
t->volumes[SPA_BT_VOLUME_ID_TX].volume = DEFAULT_TX_VOLUME;
|
|
}
|
|
|
|
for (int i = 0; i < SPA_BT_VOLUME_ID_TERM ; ++i) {
|
|
t->volumes[i].active = rfcomm->volumes[i].active;
|
|
t->volumes[i].hw_volume_max = SPA_BT_VOLUME_HS_MAX;
|
|
if (rfcomm->volumes[i].active && rfcomm->volumes[i].hw_volume != SPA_BT_VOLUME_INVALID)
|
|
t->volumes[i].volume =
|
|
spa_bt_volume_hw_to_linear(rfcomm->volumes[i].hw_volume, t->volumes[i].hw_volume_max);
|
|
}
|
|
|
|
spa_bt_transport_add_listener(t, &rfcomm->transport_listener, &transport_events, rfcomm);
|
|
|
|
return t;
|
|
}
|
|
|
|
static int codec_switch_stop_timer(struct rfcomm *rfcomm);
|
|
|
|
static void volume_sync_stop_timer(struct rfcomm *rfcomm);
|
|
|
|
static void rfcomm_free(struct rfcomm *rfcomm)
|
|
{
|
|
codec_switch_stop_timer(rfcomm);
|
|
for (int i = 0; i < MAX_HF_INDICATORS; i++) {
|
|
if (rfcomm->hf_indicators[i]) {
|
|
free(rfcomm->hf_indicators[i]);
|
|
}
|
|
}
|
|
spa_list_remove(&rfcomm->link);
|
|
if (rfcomm->path)
|
|
free(rfcomm->path);
|
|
if (rfcomm->transport) {
|
|
spa_hook_remove(&rfcomm->transport_listener);
|
|
spa_bt_transport_free(rfcomm->transport);
|
|
}
|
|
if (rfcomm->device) {
|
|
spa_bt_device_report_battery_level(rfcomm->device, SPA_BT_NO_BATTERY);
|
|
spa_hook_remove(&rfcomm->device_listener);
|
|
rfcomm->device = NULL;
|
|
}
|
|
if (rfcomm->source.fd >= 0) {
|
|
if (rfcomm->source.loop)
|
|
spa_loop_remove_source(rfcomm->source.loop, &rfcomm->source);
|
|
shutdown(rfcomm->source.fd, SHUT_RDWR);
|
|
close (rfcomm->source.fd);
|
|
rfcomm->source.fd = -1;
|
|
}
|
|
if (rfcomm->volume_sync_timer)
|
|
spa_loop_utils_destroy_source(rfcomm->backend->loop_utils, rfcomm->volume_sync_timer);
|
|
free(rfcomm);
|
|
}
|
|
|
|
#define RFCOMM_MESSAGE_MAX_LENGTH 256
|
|
|
|
/* from HF/HS to AG */
|
|
SPA_PRINTF_FUNC(2, 3)
|
|
static ssize_t rfcomm_send_cmd(const struct rfcomm *rfcomm, const char *format, ...)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
char message[RFCOMM_MESSAGE_MAX_LENGTH + 1];
|
|
ssize_t len;
|
|
va_list args;
|
|
|
|
va_start(args, format);
|
|
len = vsnprintf(message, RFCOMM_MESSAGE_MAX_LENGTH + 1, format, args);
|
|
va_end(args);
|
|
|
|
if (len < 0)
|
|
return -EINVAL;
|
|
|
|
if (len > RFCOMM_MESSAGE_MAX_LENGTH)
|
|
return -E2BIG;
|
|
|
|
spa_log_debug(backend->log, "RFCOMM >> %s", message);
|
|
|
|
/*
|
|
* The format of an AT command from the HF to the AG shall be: <AT command><cr>
|
|
* - HFP 1.8, 4.34.1
|
|
*
|
|
* The format for a command from the HS to the AG is thus: AT<cmd>=<value><cr>
|
|
* - HSP 1.2, 4.8.1
|
|
*/
|
|
message[len] = '\r';
|
|
/* `message` is no longer null-terminated */
|
|
|
|
len = write(rfcomm->source.fd, message, len + 1);
|
|
/* we ignore any errors, it's not critical and real errors should
|
|
* be caught with the HANGUP and ERROR events handled above */
|
|
if (len < 0) {
|
|
len = -errno;
|
|
spa_log_error(backend->log, "RFCOMM write error: %s", strerror(errno));
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
/* from AG to HF/HS */
|
|
SPA_PRINTF_FUNC(2, 3)
|
|
static ssize_t rfcomm_send_reply(const struct rfcomm *rfcomm, const char *format, ...)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
char message[RFCOMM_MESSAGE_MAX_LENGTH + 4];
|
|
ssize_t len;
|
|
va_list args;
|
|
|
|
va_start(args, format);
|
|
len = vsnprintf(&message[2], RFCOMM_MESSAGE_MAX_LENGTH + 1, format, args);
|
|
va_end(args);
|
|
|
|
if (len < 0)
|
|
return -EINVAL;
|
|
|
|
if (len > RFCOMM_MESSAGE_MAX_LENGTH)
|
|
return -E2BIG;
|
|
|
|
spa_log_debug(backend->log, "RFCOMM >> %s", &message[2]);
|
|
|
|
/*
|
|
* The format of the OK code from the AG to the HF shall be: <cr><lf>OK<cr><lf>
|
|
* The format of the generic ERROR code from the AG to the HF shall be: <cr><lf>ERROR<cr><lf>
|
|
* The format of an unsolicited result code from the AG to the HF shall be: <cr><lf><result code><cr><lf>
|
|
* - HFP 1.8, 4.34.1
|
|
*
|
|
* If the command is processed successfully, the resulting response from the AG to the HS is: <cr><lf>OK<cr><lf>
|
|
* If the command is not processed successfully, or is not recognized,
|
|
* the resulting response from the AG to the HS is: <cr><lf>ERROR<cr><lf>
|
|
* The format for an unsolicited result code (such as RING) from the AG to the HS is: <cr><lf><result code><cr><lf>
|
|
* - HSP 1.2, 4.8.1
|
|
*/
|
|
message[0] = '\r';
|
|
message[1] = '\n';
|
|
message[len + 2] = '\r';
|
|
message[len + 3] = '\n';
|
|
/* `message` is no longer null-terminated */
|
|
|
|
len = write(rfcomm->source.fd, message, len + 4);
|
|
/* we ignore any errors, it's not critical and real errors should
|
|
* be caught with the HANGUP and ERROR events handled above */
|
|
if (len < 0) {
|
|
len = -errno;
|
|
spa_log_error(backend->log, "RFCOMM write error: %s", strerror(errno));
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
static void rfcomm_send_error(const struct rfcomm *rfcomm, enum cmee_error error)
|
|
{
|
|
if (rfcomm->extended_error_reporting)
|
|
rfcomm_send_reply(rfcomm, "+CME ERROR: %d", error);
|
|
else
|
|
rfcomm_send_reply(rfcomm, "ERROR");
|
|
}
|
|
|
|
static bool rfcomm_volume_enabled(struct rfcomm *rfcomm)
|
|
{
|
|
return rfcomm->device != NULL
|
|
&& (rfcomm->device->hw_volume_profiles & rfcomm->profile);
|
|
}
|
|
|
|
static void rfcomm_emit_volume_changed(struct rfcomm *rfcomm, int id, int hw_volume)
|
|
{
|
|
struct spa_bt_transport_volume *t_volume;
|
|
|
|
if (!rfcomm_volume_enabled(rfcomm))
|
|
return;
|
|
|
|
if ((id == SPA_BT_VOLUME_ID_RX || id == SPA_BT_VOLUME_ID_TX) && hw_volume >= 0) {
|
|
rfcomm->volumes[id].active = true;
|
|
rfcomm->volumes[id].hw_volume = hw_volume;
|
|
}
|
|
|
|
spa_log_debug(rfcomm->backend->log, "volume changed %d", hw_volume);
|
|
|
|
if (rfcomm->transport == NULL || !rfcomm->has_volume)
|
|
return;
|
|
|
|
for (int i = 0; i < SPA_BT_VOLUME_ID_TERM ; ++i) {
|
|
t_volume = &rfcomm->transport->volumes[i];
|
|
t_volume->active = rfcomm->volumes[i].active;
|
|
t_volume->volume =
|
|
spa_bt_volume_hw_to_linear(rfcomm->volumes[i].hw_volume, t_volume->hw_volume_max);
|
|
}
|
|
|
|
spa_bt_transport_emit_volume_changed(rfcomm->transport);
|
|
}
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HSP_NATIVE
|
|
static bool rfcomm_hsp_ag(struct rfcomm *rfcomm, char* buf)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
unsigned int gain, dummy;
|
|
|
|
/* There are only three HSP AT commands:
|
|
* AT+VGS=value: value between 0 and 15, sent by the HS to AG to set the speaker gain.
|
|
* AT+VGM=value: value between 0 and 15, sent by the HS to AG to set the microphone gain.
|
|
* AT+CKPD=200: Sent by HS when headset button is pressed. */
|
|
if (sscanf(buf, "AT+VGS=%d", &gain) == 1) {
|
|
if (gain <= SPA_BT_VOLUME_HS_MAX) {
|
|
rfcomm_emit_volume_changed(rfcomm, SPA_BT_VOLUME_ID_TX, gain);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else {
|
|
spa_log_debug(backend->log, "RFCOMM receive unsupported VGS gain: %s", buf);
|
|
rfcomm_send_reply(rfcomm, "ERROR");
|
|
}
|
|
} else if (sscanf(buf, "AT+VGM=%d", &gain) == 1) {
|
|
if (gain <= SPA_BT_VOLUME_HS_MAX) {
|
|
if (!rfcomm->broken_mic_hw_volume)
|
|
rfcomm_emit_volume_changed(rfcomm, SPA_BT_VOLUME_ID_RX, gain);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else {
|
|
rfcomm_send_reply(rfcomm, "ERROR");
|
|
spa_log_debug(backend->log, "RFCOMM receive unsupported VGM gain: %s", buf);
|
|
}
|
|
} else if (sscanf(buf, "AT+CKPD=%d", &dummy) == 1) {
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool rfcomm_send_volume_cmd(struct rfcomm *rfcomm, int id)
|
|
{
|
|
struct spa_bt_transport_volume *t_volume;
|
|
const char *format;
|
|
int hw_volume;
|
|
|
|
if (!rfcomm_volume_enabled(rfcomm))
|
|
return false;
|
|
|
|
t_volume = rfcomm->transport ? &rfcomm->transport->volumes[id] : NULL;
|
|
|
|
if (!(t_volume && t_volume->active))
|
|
return false;
|
|
|
|
hw_volume = spa_bt_volume_linear_to_hw(t_volume->volume, t_volume->hw_volume_max);
|
|
rfcomm->volumes[id].hw_volume = hw_volume;
|
|
|
|
if (id == SPA_BT_VOLUME_ID_TX)
|
|
format = "AT+VGM";
|
|
else if (id == SPA_BT_VOLUME_ID_RX)
|
|
format = "AT+VGS";
|
|
else
|
|
spa_assert_not_reached();
|
|
|
|
rfcomm_send_cmd(rfcomm, "%s=%d", format, hw_volume);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool rfcomm_hsp_hs(struct rfcomm *rfcomm, char* buf)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
unsigned int gain;
|
|
|
|
/* There are only three HSP AT result codes:
|
|
* +VGS=value: value between 0 and 15, sent by AG to HS as a response to an AT+VGS command
|
|
* or when the gain is changed on the AG side.
|
|
* +VGM=value: value between 0 and 15, sent by AG to HS as a response to an AT+VGM command
|
|
* or when the gain is changed on the AG side.
|
|
* RING: Sent by AG to HS to notify of an incoming call. It can safely be ignored because
|
|
* it does not expect a reply. */
|
|
if (sscanf(buf, "\r\n+VGS=%d\r\n", &gain) == 1) {
|
|
if (gain <= SPA_BT_VOLUME_HS_MAX) {
|
|
rfcomm_emit_volume_changed(rfcomm, SPA_BT_VOLUME_ID_RX, gain);
|
|
} else {
|
|
spa_log_debug(backend->log, "RFCOMM receive unsupported VGS gain: %s", buf);
|
|
}
|
|
} else if (sscanf(buf, "\r\n+VGM=%d\r\n", &gain) == 1) {
|
|
if (gain <= SPA_BT_VOLUME_HS_MAX) {
|
|
rfcomm_emit_volume_changed(rfcomm, SPA_BT_VOLUME_ID_TX, gain);
|
|
} else {
|
|
spa_log_debug(backend->log, "RFCOMM receive unsupported VGM gain: %s", buf);
|
|
}
|
|
} else if (spa_strstartswith(buf, "\r\nOK\r\n")) {
|
|
if (rfcomm->hs_state == hsp_hs_init2) {
|
|
if (rfcomm_send_volume_cmd(rfcomm, SPA_BT_VOLUME_ID_RX))
|
|
rfcomm->hs_state = hsp_hs_vgs;
|
|
else
|
|
rfcomm->hs_state = hsp_hs_init1;
|
|
} else if (rfcomm->hs_state == hsp_hs_vgs) {
|
|
if (rfcomm_send_volume_cmd(rfcomm, SPA_BT_VOLUME_ID_TX))
|
|
rfcomm->hs_state = hsp_hs_vgm;
|
|
else
|
|
rfcomm->hs_state = hsp_hs_init1;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_LIBUSB
|
|
static bool check_usb_altsetting_6(struct impl *backend, uint16_t vendor_id, uint16_t product_id)
|
|
{
|
|
libusb_context *ctx = NULL;
|
|
struct libusb_config_descriptor *cfg = NULL;
|
|
libusb_device **devices = NULL;
|
|
|
|
ssize_t ndev, idev;
|
|
int res;
|
|
bool ok = false;
|
|
|
|
if ((res = libusb_init(&ctx)) < 0) {
|
|
ctx = NULL;
|
|
goto fail;
|
|
}
|
|
|
|
if ((ndev = libusb_get_device_list(ctx, &devices)) < 0) {
|
|
res = ndev;
|
|
devices = NULL;
|
|
goto fail;
|
|
}
|
|
|
|
for (idev = 0; idev < ndev; ++idev) {
|
|
libusb_device *dev = devices[idev];
|
|
struct libusb_device_descriptor desc;
|
|
int icfg;
|
|
|
|
libusb_get_device_descriptor(dev, &desc);
|
|
if (vendor_id != desc.idVendor || product_id != desc.idProduct)
|
|
continue;
|
|
|
|
/* Check the device has Bluetooth isoch. altsetting 6 interface */
|
|
|
|
for (icfg = 0; icfg < desc.bNumConfigurations; ++icfg) {
|
|
int iiface;
|
|
|
|
if ((res = libusb_get_config_descriptor(dev, icfg, &cfg)) != 0) {
|
|
cfg = NULL;
|
|
goto fail;
|
|
}
|
|
|
|
for (iiface = 0; iiface < cfg->bNumInterfaces; ++iiface) {
|
|
const struct libusb_interface *iface = &cfg->interface[iiface];
|
|
int ialt;
|
|
|
|
for (ialt = 0; ialt < iface->num_altsetting; ++ialt) {
|
|
const struct libusb_interface_descriptor *idesc = &iface->altsetting[ialt];
|
|
int iep;
|
|
|
|
if (idesc->bInterfaceClass != LIBUSB_CLASS_WIRELESS ||
|
|
idesc->bInterfaceSubClass != 1 /* RF */ ||
|
|
idesc->bInterfaceProtocol != 1 /* Bluetooth */ ||
|
|
idesc->bAlternateSetting != 6)
|
|
continue;
|
|
|
|
for (iep = 0; iep < idesc->bNumEndpoints; ++iep) {
|
|
const struct libusb_endpoint_descriptor *ep = &idesc->endpoint[iep];
|
|
if ((ep->bmAttributes & 0x3) == 0x1 /* isochronous */) {
|
|
ok = true;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
libusb_free_config_descriptor(cfg);
|
|
cfg = NULL;
|
|
}
|
|
}
|
|
|
|
done:
|
|
if (cfg)
|
|
libusb_free_config_descriptor(cfg);
|
|
if (devices)
|
|
libusb_free_device_list(devices, 0);
|
|
if (ctx)
|
|
libusb_exit(ctx);
|
|
return ok;
|
|
|
|
fail:
|
|
spa_log_info(backend->log, "failed to acquire USB device info: %d (%s)",
|
|
res, libusb_strerror(res));
|
|
ok = false;
|
|
goto done;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
|
|
static bool device_supports_required_mSBC_transport_modes(
|
|
struct impl *backend, struct spa_bt_device *device)
|
|
{
|
|
int res;
|
|
bool msbc_ok, msbc_alt1_ok;
|
|
uint32_t bt_features;
|
|
|
|
if (device->adapter == NULL)
|
|
return false;
|
|
|
|
if (backend->quirks && spa_bt_quirks_get_features(backend->quirks, device->adapter, device, &bt_features) == 0) {
|
|
msbc_ok = bt_features & SPA_BT_FEATURE_MSBC;
|
|
msbc_alt1_ok = bt_features & (SPA_BT_FEATURE_MSBC_ALT1 | SPA_BT_FEATURE_MSBC_ALT1_RTL);
|
|
} else {
|
|
msbc_ok = true;
|
|
msbc_alt1_ok = true;
|
|
}
|
|
|
|
spa_log_info(backend->log,
|
|
"bluez-monitor/hardware.conf: msbc:%d msbc-alt1:%d", (int)msbc_ok, (int)msbc_alt1_ok);
|
|
|
|
if (!msbc_ok && !msbc_alt1_ok)
|
|
return false;
|
|
|
|
res = spa_bt_adapter_has_msbc(device->adapter);
|
|
if (res < 0) {
|
|
spa_log_warn(backend->log,
|
|
"adapter %s: failed to determine msbc/esco capability (%d)",
|
|
device->adapter->path, res);
|
|
} else if (res == 0) {
|
|
spa_log_info(backend->log,
|
|
"adapter %s: no msbc/esco transport",
|
|
device->adapter->path);
|
|
return false;
|
|
} else {
|
|
spa_log_debug(backend->log,
|
|
"adapter %s: has msbc/esco transport",
|
|
device->adapter->path);
|
|
}
|
|
|
|
/* Check if USB ALT6 is really available on the device */
|
|
if (device->adapter->bus_type == BUS_TYPE_USB && !msbc_alt1_ok && msbc_ok) {
|
|
#ifdef HAVE_LIBUSB
|
|
if (device->adapter->source_id == SOURCE_ID_USB) {
|
|
msbc_ok = check_usb_altsetting_6(backend, device->adapter->vendor_id,
|
|
device->adapter->product_id);
|
|
} else {
|
|
msbc_ok = false;
|
|
}
|
|
if (!msbc_ok)
|
|
spa_log_info(backend->log, "bluetooth host adapter does not support USB ALT6");
|
|
#else
|
|
spa_log_info(backend->log,
|
|
"compiled without libusb; can't check if bluetooth adapter has USB ALT6");
|
|
msbc_ok = false;
|
|
#endif
|
|
}
|
|
if (device->adapter->bus_type != BUS_TYPE_USB)
|
|
msbc_alt1_ok = false;
|
|
|
|
return msbc_ok || msbc_alt1_ok;
|
|
}
|
|
|
|
static int codec_switch_start_timer(struct rfcomm *rfcomm, int timeout_msec);
|
|
|
|
static void process_xevent_indicator(struct rfcomm *rfcomm, unsigned int level, unsigned int nlevels)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
uint8_t perc;
|
|
|
|
spa_log_debug(backend->log, "AT+XEVENT level:%u nlevels:%u", level, nlevels);
|
|
|
|
if (nlevels <= 1)
|
|
return;
|
|
|
|
/* 0 <= level < nlevels */
|
|
perc = SPA_MIN(level, nlevels - 1) * 100 / (nlevels - 1);
|
|
spa_bt_device_report_battery_level(rfcomm->device, perc);
|
|
}
|
|
|
|
static void process_iphoneaccev_indicator(struct rfcomm *rfcomm, unsigned int key, unsigned int value)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
|
|
spa_log_debug(backend->log, "key:%u value:%u", key, value);
|
|
|
|
switch (key) {
|
|
case SPA_BT_HFP_HF_IPHONEACCEV_KEY_BATTERY_LEVEL: {
|
|
// Battery level is reported in range of 0-9, convert to 10-100%
|
|
uint8_t level = (SPA_CLAMP(value, 0u, 9u) + 1) * 10;
|
|
spa_log_debug(backend->log, "battery level: %d%%", (int) level);
|
|
|
|
// TODO: report without Battery Provider (using props)
|
|
spa_bt_device_report_battery_level(rfcomm->device, level);
|
|
break;
|
|
}
|
|
case SPA_BT_HFP_HF_IPHONEACCEV_KEY_DOCK_STATE:
|
|
break;
|
|
default:
|
|
spa_log_warn(backend->log, "unknown AT+IPHONEACCEV key:%u value:%u", key, value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void process_hfp_hf_indicator(struct rfcomm *rfcomm, unsigned int indicator, unsigned int value)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
|
|
spa_log_debug(backend->log, "indicator:%u value:%u", indicator, value);
|
|
|
|
switch (indicator) {
|
|
case SPA_BT_HFP_HF_INDICATOR_ENHANCED_SAFETY:
|
|
break;
|
|
case SPA_BT_HFP_HF_INDICATOR_BATTERY_LEVEL:
|
|
// Battery level is reported in range 0-100
|
|
spa_log_debug(backend->log, "battery level: %u%%", value);
|
|
|
|
if (value <= 100) {
|
|
// TODO: report without Battery Provider (using props)
|
|
spa_bt_device_report_battery_level(rfcomm->device, value);
|
|
} else {
|
|
spa_log_warn(backend->log, "battery HF indicator %u outside of range [0, 100]: %u", indicator, value);
|
|
}
|
|
break;
|
|
default:
|
|
spa_log_warn(backend->log, "unknown HF indicator:%u value:%u", indicator, value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void rfcomm_hfp_ag_set_cind(struct rfcomm *rfcomm, bool call_active)
|
|
{
|
|
if (rfcomm->profile != SPA_BT_PROFILE_HFP_HF)
|
|
return;
|
|
|
|
if (call_active == rfcomm->cind_call_active)
|
|
return;
|
|
|
|
rfcomm->cind_call_active = call_active;
|
|
|
|
if (!rfcomm->cind_call_notify)
|
|
return;
|
|
|
|
rfcomm_send_reply(rfcomm, "+CIEV: 2,%d", rfcomm->cind_call_active);
|
|
}
|
|
|
|
static bool rfcomm_hfp_ag(struct rfcomm *rfcomm, char* buf)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
unsigned int features;
|
|
unsigned int gain;
|
|
unsigned int count, r;
|
|
unsigned int selected_codec;
|
|
unsigned int indicator;
|
|
unsigned int indicator_value;
|
|
unsigned int value;
|
|
unsigned int xevent_level;
|
|
unsigned int xevent_nlevels;
|
|
int xapl_vendor;
|
|
int xapl_product;
|
|
int xapl_features;
|
|
|
|
spa_debug_log_mem(backend->log, SPA_LOG_LEVEL_DEBUG, 2, buf, strlen(buf));
|
|
|
|
/* Some devices send initial \n: be permissive */
|
|
while (*buf == '\n')
|
|
++buf;
|
|
|
|
if (sscanf(buf, "AT+BRSF=%u", &features) == 1) {
|
|
unsigned int ag_features = SPA_BT_HFP_AG_FEATURE_NONE;
|
|
|
|
/*
|
|
* Determine device volume control. Some headsets only support control of
|
|
* TX volume, but not RX, even if they have a microphone. Determine this
|
|
* separately based on whether we also get AT+VGS/AT+VGM, and quirks.
|
|
*/
|
|
rfcomm->has_volume = (features & SPA_BT_HFP_HF_FEATURE_REMOTE_VOLUME_CONTROL);
|
|
|
|
/* Decide if we want to signal that the computer supports mSBC negotiation
|
|
This should be done when the computers bluetooth adapter supports the necessary transport mode */
|
|
if (device_supports_required_mSBC_transport_modes(backend, rfcomm->device)) {
|
|
|
|
/* set the feature bit that indicates AG (=computer) supports codec negotiation */
|
|
ag_features |= SPA_BT_HFP_AG_FEATURE_CODEC_NEGOTIATION;
|
|
|
|
/* let's see if the headset supports codec negotiation */
|
|
if ((features & (SPA_BT_HFP_HF_FEATURE_CODEC_NEGOTIATION)) != 0) {
|
|
spa_log_debug(backend->log,
|
|
"RFCOMM features = %i, codec negotiation supported by headset",
|
|
features);
|
|
/* Prepare reply: Audio Gateway (=computer) supports codec negotiation */
|
|
rfcomm->codec_negotiation_supported = true;
|
|
rfcomm->msbc_supported_by_hfp = false;
|
|
} else {
|
|
/* Codec negotiation not supported */
|
|
spa_log_debug(backend->log,
|
|
"RFCOMM features = %i, codec negotiation NOT supported by headset",
|
|
features);
|
|
|
|
rfcomm->codec_negotiation_supported = false;
|
|
rfcomm->msbc_supported_by_hfp = false;
|
|
}
|
|
}
|
|
|
|
/* send reply to HF with the features supported by Audio Gateway (=computer) */
|
|
ag_features |= mm_supported_features();
|
|
ag_features |= SPA_BT_HFP_AG_FEATURE_HF_INDICATORS;
|
|
rfcomm_send_reply(rfcomm, "+BRSF: %u", ag_features);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+BAC=")) {
|
|
/* retrieve supported codecs */
|
|
/* response has the form AT+BAC=<codecID1>,<codecID2>,<codecIDx>
|
|
strategy: split the string into tokens */
|
|
|
|
char* token;
|
|
int cntr = 0;
|
|
|
|
while ((token = strsep(&buf, "=,"))) {
|
|
unsigned int codec_id;
|
|
|
|
/* skip token 0 i.e. the "AT+BAC=" part */
|
|
if (cntr > 0 && sscanf(token, "%u", &codec_id) == 1) {
|
|
spa_log_debug(backend->log, "RFCOMM AT+BAC found codec %u", codec_id);
|
|
if (codec_id == HFP_AUDIO_CODEC_MSBC) {
|
|
rfcomm->msbc_supported_by_hfp = true;
|
|
spa_log_debug(backend->log, "RFCOMM headset supports mSBC codec");
|
|
}
|
|
}
|
|
cntr++;
|
|
}
|
|
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+CIND=?")) {
|
|
rfcomm_send_reply(rfcomm, "+CIND:%s", CIND_INDICATORS);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+CIND?")) {
|
|
rfcomm_send_reply(rfcomm, "+CIND: %d,%d,%d,0,%d,%d,%d", backend->modem.network_has_service,
|
|
backend->modem.active_call, backend->modem.call_setup, backend->modem.signal_strength,
|
|
backend->modem.network_is_roaming, backend->battery_level);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+CMER")) {
|
|
int mode, keyp, disp, ind;
|
|
|
|
rfcomm->slc_configured = true;
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
|
|
rfcomm->cind_call_active = false;
|
|
if (sscanf(buf, "AT+CMER= %d , %d , %d , %d", &mode, &keyp, &disp, &ind) == 4)
|
|
rfcomm->cind_call_notify = ind ? true : false;
|
|
else
|
|
rfcomm->cind_call_notify = false;
|
|
|
|
/* switch codec to mSBC by sending unsolicited +BCS message */
|
|
if (rfcomm->codec_negotiation_supported && rfcomm->msbc_supported_by_hfp) {
|
|
spa_log_debug(backend->log, "RFCOMM initial codec setup");
|
|
rfcomm->hfp_ag_initial_codec_setup = HFP_AG_INITIAL_CODEC_SETUP_SEND;
|
|
rfcomm_send_reply(rfcomm, "+BCS: 2");
|
|
codec_switch_start_timer(rfcomm, HFP_CODEC_SWITCH_INITIAL_TIMEOUT_MSEC);
|
|
} else {
|
|
rfcomm->transport = _transport_create(rfcomm);
|
|
if (rfcomm->transport == NULL) {
|
|
spa_log_warn(backend->log, "can't create transport: %m");
|
|
// TODO: We should manage the missing transport
|
|
} else {
|
|
rfcomm->transport->codec = HFP_AUDIO_CODEC_CVSD;
|
|
spa_bt_device_connect_profile(rfcomm->device, rfcomm->profile);
|
|
rfcomm_emit_volume_changed(rfcomm, -1, SPA_BT_VOLUME_INVALID);
|
|
}
|
|
}
|
|
} else if (spa_streq(buf, "\r")) {
|
|
/* No commands, reply OK (ITU-T Rec. V.250 Sec. 5.2.1 & 5.6) */
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (!rfcomm->slc_configured) {
|
|
spa_log_warn(backend->log, "RFCOMM receive command before SLC completed: %s", buf);
|
|
rfcomm_send_error(rfcomm, CMEE_AG_FAILURE);
|
|
return true;
|
|
|
|
/* *****
|
|
* Following commands requires a Service Level Connection
|
|
* ***** */
|
|
|
|
} else if (sscanf(buf, "AT+BCS=%u", &selected_codec) == 1) {
|
|
/* parse BCS(=Bluetooth Codec Selection) reply */
|
|
bool was_switching_codec = rfcomm->hfp_ag_switching_codec && (rfcomm->device != NULL);
|
|
rfcomm->hfp_ag_switching_codec = false;
|
|
rfcomm->hfp_ag_initial_codec_setup = HFP_AG_INITIAL_CODEC_SETUP_NONE;
|
|
codec_switch_stop_timer(rfcomm);
|
|
volume_sync_stop_timer(rfcomm);
|
|
|
|
if (selected_codec != HFP_AUDIO_CODEC_CVSD && selected_codec != HFP_AUDIO_CODEC_MSBC) {
|
|
spa_log_warn(backend->log, "unsupported codec negotiation: %d", selected_codec);
|
|
rfcomm_send_error(rfcomm, CMEE_AG_FAILURE);
|
|
if (was_switching_codec)
|
|
spa_bt_device_emit_codec_switched(rfcomm->device, -EIO);
|
|
return true;
|
|
}
|
|
|
|
rfcomm->codec = selected_codec;
|
|
|
|
spa_log_debug(backend->log, "RFCOMM selected_codec = %i", selected_codec);
|
|
|
|
/* Recreate transport, since previous connection may now be invalid */
|
|
if (rfcomm->transport)
|
|
spa_bt_transport_free(rfcomm->transport);
|
|
|
|
rfcomm->transport = _transport_create(rfcomm);
|
|
if (rfcomm->transport == NULL) {
|
|
spa_log_warn(backend->log, "can't create transport: %m");
|
|
// TODO: We should manage the missing transport
|
|
rfcomm_send_error(rfcomm, CMEE_AG_FAILURE);
|
|
if (was_switching_codec)
|
|
spa_bt_device_emit_codec_switched(rfcomm->device, -ENOMEM);
|
|
return true;
|
|
}
|
|
rfcomm->transport->codec = selected_codec;
|
|
spa_bt_device_connect_profile(rfcomm->device, rfcomm->profile);
|
|
rfcomm_emit_volume_changed(rfcomm, -1, SPA_BT_VOLUME_INVALID);
|
|
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
if (was_switching_codec)
|
|
spa_bt_device_emit_codec_switched(rfcomm->device, 0);
|
|
} else if (spa_strstartswith(buf, "AT+BCC")) {
|
|
if (!rfcomm->codec_negotiation_supported)
|
|
return false;
|
|
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
rfcomm_send_reply(rfcomm, "+BCS: %u", rfcomm->codec);
|
|
rfcomm->hfp_ag_switching_codec = true;
|
|
rfcomm->hfp_ag_initial_codec_setup = HFP_AG_INITIAL_CODEC_SETUP_NONE;
|
|
codec_switch_start_timer(rfcomm, HFP_CODEC_SWITCH_TIMEOUT_MSEC);
|
|
} else if (spa_strstartswith(buf, "AT+BIA=")) {
|
|
/* retrieve indicators activation
|
|
* form: AT+BIA=[indrep1],[indrep2],[indrepx] */
|
|
char *str = buf + 7;
|
|
unsigned int ind = 1;
|
|
|
|
while (*str && ind < CIND_MAX && *str != '\r' && *str != '\n') {
|
|
if (*str == ',') {
|
|
ind++;
|
|
goto next_indicator;
|
|
}
|
|
|
|
/* Ignore updates to mandantory indicators which are always ON */
|
|
if (ind == CIND_CALL || ind == CIND_CALLSETUP || ind == CIND_CALLHELD)
|
|
goto next_indicator;
|
|
|
|
switch (*str) {
|
|
case '0':
|
|
rfcomm->cind_enabled_indicators &= ~(1 << ind);
|
|
break;
|
|
case '1':
|
|
rfcomm->cind_enabled_indicators |= (1 << ind);
|
|
break;
|
|
default:
|
|
spa_log_warn(backend->log, "Unsupported entry in %s: %c", buf, *str);
|
|
}
|
|
next_indicator:
|
|
str++;
|
|
}
|
|
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+CLCC")) {
|
|
struct spa_list *calls;
|
|
struct call *call;
|
|
unsigned int type;
|
|
|
|
if (backend->modemmanager) {
|
|
calls = mm_get_calls(backend->modemmanager);
|
|
spa_list_for_each(call, calls, link) {
|
|
if (!call->number) {
|
|
rfcomm_send_reply(rfcomm, "+CLCC: %u,%u,%u,0,%u", call->index, call->direction, call->state, call->multiparty);
|
|
} else {
|
|
if (spa_strstartswith(call->number, "+"))
|
|
type = INTERNATIONAL_NUMBER;
|
|
else
|
|
type = NATIONAL_NUMBER;
|
|
rfcomm_send_reply(rfcomm, "+CLCC: %u,%u,%u,0,%u,\"%s\",%d", call->index, call->direction, call->state,
|
|
call->multiparty, call->number, type);
|
|
}
|
|
}
|
|
}
|
|
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (sscanf(buf, "AT+CLIP=%u", &value) == 1) {
|
|
if (value > 1) {
|
|
spa_log_debug(backend->log, "Unsupported AT+CLIP value: %u", value);
|
|
rfcomm_send_error(rfcomm, CMEE_AG_FAILURE);
|
|
return true;
|
|
}
|
|
|
|
rfcomm->clip_notify = value;
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (sscanf(buf, "AT+CMEE=%u", &value) == 1) {
|
|
if (value > 1) {
|
|
spa_log_debug(backend->log, "Unsupported AT+CMEE value: %u", value);
|
|
rfcomm_send_error(rfcomm, CMEE_AG_FAILURE);
|
|
return true;
|
|
}
|
|
|
|
rfcomm->extended_error_reporting = value;
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+CNUM")) {
|
|
if (backend->modem.own_number) {
|
|
unsigned int type;
|
|
if (spa_strstartswith(backend->modem.own_number, "+"))
|
|
type = INTERNATIONAL_NUMBER;
|
|
else
|
|
type = NATIONAL_NUMBER;
|
|
rfcomm_send_reply(rfcomm, "+CNUM: ,\"%s\",%u", backend->modem.own_number, type);
|
|
}
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+COPS=")) {
|
|
unsigned int mode, val;
|
|
|
|
if (sscanf(buf, "AT+COPS=%u,%u", &mode, &val) != 2 ||
|
|
mode != 3 || val != 0) {
|
|
rfcomm_send_error(rfcomm, CMEE_AG_FAILURE);
|
|
} else {
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
}
|
|
} else if (spa_strstartswith(buf, "AT+COPS?")) {
|
|
if (!backend->modem.network_has_service) {
|
|
rfcomm_send_error(rfcomm, CMEE_NO_NETWORK_SERVICE);
|
|
} else {
|
|
if (backend->modem.operator_name)
|
|
rfcomm_send_reply(rfcomm, "+COPS: 0,0,\"%s\"", backend->modem.operator_name);
|
|
else
|
|
rfcomm_send_reply(rfcomm, "+COPS: 0,,");
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
}
|
|
} else if (sscanf(buf, "AT+VGM=%u", &gain) == 1) {
|
|
if (gain <= SPA_BT_VOLUME_HS_MAX) {
|
|
if (!rfcomm->broken_mic_hw_volume)
|
|
rfcomm_emit_volume_changed(rfcomm, SPA_BT_VOLUME_ID_RX, gain);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else {
|
|
spa_log_debug(backend->log, "RFCOMM receive unsupported VGM gain: %s", buf);
|
|
rfcomm_send_error(rfcomm, CMEE_OPERATION_NOT_ALLOWED);
|
|
}
|
|
} else if (sscanf(buf, "AT+VGS=%u", &gain) == 1) {
|
|
if (gain <= SPA_BT_VOLUME_HS_MAX) {
|
|
rfcomm_emit_volume_changed(rfcomm, SPA_BT_VOLUME_ID_TX, gain);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else {
|
|
spa_log_debug(backend->log, "RFCOMM receive unsupported VGS gain: %s", buf);
|
|
rfcomm_send_error(rfcomm, CMEE_OPERATION_NOT_ALLOWED);
|
|
}
|
|
} else if (spa_strstartswith(buf, "AT+BIND=?")) {
|
|
rfcomm_send_reply(rfcomm, "+BIND: (2)");
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+BIND?")) {
|
|
rfcomm_send_reply(rfcomm, "+BIND: 2,1");
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+BIND=")) {
|
|
// BIND=... should return a comma separated list of indicators and
|
|
// 2 should be among the other numbers telling that battery charge
|
|
// is supported
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (sscanf(buf, "AT+BIEV=%u,%u", &indicator, &indicator_value) == 2) {
|
|
process_hfp_hf_indicator(rfcomm, indicator, indicator_value);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (sscanf(buf, "AT+XAPL=%04x-%04x-%*[^,],%u", &xapl_vendor, &xapl_product, &xapl_features) == 3) {
|
|
if (xapl_features & SPA_BT_HFP_HF_XAPL_FEATURE_BATTERY_REPORTING) {
|
|
/* claim, that we support battery status reports */
|
|
rfcomm_send_reply(rfcomm, "+XAPL=iPhone,%u", SPA_BT_HFP_HF_XAPL_FEATURE_BATTERY_REPORTING);
|
|
}
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+XEVENT=USER-AGENT")) {
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (sscanf(buf, "AT+XEVENT=BATTERY,%u,%u,%*u,%*u", &xevent_level, &xevent_nlevels) == 2) {
|
|
process_xevent_indicator(rfcomm, xevent_level, xevent_nlevels);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (sscanf(buf, "AT+XEVENT=BATTERY,%u", &xevent_level) == 1) {
|
|
process_xevent_indicator(rfcomm, xevent_level + 1, 11);
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (sscanf(buf, "AT+IPHONEACCEV=%u%n", &count, &r) == 1) {
|
|
if (count < 1 || count > 100)
|
|
return false;
|
|
|
|
buf += r;
|
|
|
|
for (unsigned int i = 0; i < count; i++) {
|
|
unsigned int key, value;
|
|
|
|
if (sscanf(buf, " , %u , %u%n", &key, &value, &r) != 2)
|
|
return false;
|
|
|
|
process_iphoneaccev_indicator(rfcomm, key, value);
|
|
buf += r;
|
|
}
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (spa_strstartswith(buf, "AT+APLSIRI?")) {
|
|
// This command is sent when we activate Apple extensions
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
} else if (!mm_is_available(backend->modemmanager)) {
|
|
spa_log_warn(backend->log, "RFCOMM receive command but modem not available: %s", buf);
|
|
rfcomm_send_error(rfcomm, CMEE_NO_CONNECTION_TO_PHONE);
|
|
return true;
|
|
|
|
/* *****
|
|
* Following commands requires a Service Level Connection
|
|
* and acces to a modem
|
|
* ***** */
|
|
|
|
} else if (!backend->modem.network_has_service) {
|
|
spa_log_warn(backend->log, "RFCOMM receive command but network not available: %s", buf);
|
|
rfcomm_send_error(rfcomm, CMEE_NO_NETWORK_SERVICE);
|
|
return true;
|
|
|
|
/* *****
|
|
* Following commands requires a Service Level Connection,
|
|
* acces to a modem and to the network
|
|
* ***** */
|
|
|
|
} else if (spa_strstartswith(buf, "ATA")) {
|
|
enum cmee_error error;
|
|
|
|
if (!mm_answer_call(backend->modemmanager, rfcomm, &error)) {
|
|
rfcomm_send_error(rfcomm, error);
|
|
return true;
|
|
}
|
|
} else if (spa_strstartswith(buf, "ATD")) {
|
|
char number[31], sep;
|
|
enum cmee_error error;
|
|
|
|
if (sscanf(buf, "ATD%30[^;]%c", number, &sep) != 2 || sep != ';') {
|
|
spa_log_debug(backend->log, "Failed to parse ATD: \"%s\"", buf);
|
|
rfcomm_send_error(rfcomm, CMEE_AG_FAILURE);
|
|
return true;
|
|
}
|
|
|
|
if (!mm_do_call(backend->modemmanager, number, rfcomm, &error)) {
|
|
rfcomm_send_error(rfcomm, error);
|
|
return true;
|
|
}
|
|
} else if (spa_strstartswith(buf, "AT+CHUP")) {
|
|
enum cmee_error error;
|
|
|
|
if (!mm_hangup_call(backend->modemmanager, rfcomm, &error)) {
|
|
rfcomm_send_error(rfcomm, error);
|
|
return true;
|
|
}
|
|
} else if (spa_strstartswith(buf, "AT+VTS=")) {
|
|
char dtmf[2];
|
|
enum cmee_error error;
|
|
|
|
if (sscanf(buf, "AT+VTS=%1s", dtmf) != 1) {
|
|
spa_log_debug(backend->log, "Failed to parse AT+VTS: \"%s\"", buf);
|
|
rfcomm_send_error(rfcomm, CMEE_AG_FAILURE);
|
|
return true;
|
|
}
|
|
|
|
if (!mm_send_dtmf(backend->modemmanager, dtmf, rfcomm, &error)) {
|
|
rfcomm_send_error(rfcomm, error);
|
|
return true;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool rfcomm_hfp_hf(struct rfcomm *rfcomm, char* buf)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
unsigned int features, gain, selected_codec, indicator, value;
|
|
char* token;
|
|
|
|
while ((token = strsep(&buf, "\r\n"))) {
|
|
if (sscanf(token, "+BRSF:%u", &features) == 1) {
|
|
if (((features & (SPA_BT_HFP_AG_FEATURE_CODEC_NEGOTIATION)) != 0) &&
|
|
rfcomm->msbc_supported_by_hfp)
|
|
rfcomm->codec_negotiation_supported = true;
|
|
} else if (sscanf(token, "+BCS:%u", &selected_codec) == 1 && rfcomm->codec_negotiation_supported) {
|
|
if (selected_codec != HFP_AUDIO_CODEC_CVSD && selected_codec != HFP_AUDIO_CODEC_MSBC) {
|
|
spa_log_warn(backend->log, "unsupported codec negotiation: %d", selected_codec);
|
|
} else {
|
|
spa_log_debug(backend->log, "RFCOMM selected_codec = %i", selected_codec);
|
|
|
|
/* send codec selection to AG */
|
|
rfcomm_send_cmd(rfcomm, "AT+BCS=%u", selected_codec);
|
|
|
|
rfcomm->hf_state = hfp_hf_bcs;
|
|
|
|
if (!rfcomm->transport || (rfcomm->transport->codec != selected_codec) ) {
|
|
if (rfcomm->transport)
|
|
spa_bt_transport_free(rfcomm->transport);
|
|
|
|
rfcomm->transport = _transport_create(rfcomm);
|
|
if (rfcomm->transport == NULL) {
|
|
spa_log_warn(backend->log, "can't create transport: %m");
|
|
// TODO: We should manage the missing transport
|
|
} else {
|
|
rfcomm->transport->codec = selected_codec;
|
|
spa_bt_device_connect_profile(rfcomm->device, rfcomm->profile);
|
|
}
|
|
}
|
|
}
|
|
} else if (sscanf(token, "+VGM%*1[:=]%u", &gain) == 1) {
|
|
if (gain <= SPA_BT_VOLUME_HS_MAX) {
|
|
rfcomm_emit_volume_changed(rfcomm, SPA_BT_VOLUME_ID_TX, gain);
|
|
} else {
|
|
spa_log_debug(backend->log, "RFCOMM receive unsupported VGM gain: %s", token);
|
|
}
|
|
} else if (sscanf(token, "+VGS%*1[:=]%u", &gain) == 1) {
|
|
if (gain <= SPA_BT_VOLUME_HS_MAX) {
|
|
rfcomm_emit_volume_changed(rfcomm, SPA_BT_VOLUME_ID_RX, gain);
|
|
} else {
|
|
spa_log_debug(backend->log, "RFCOMM receive unsupported VGS gain: %s", token);
|
|
}
|
|
} else if (spa_strstartswith(token, "+CIND: (")) {
|
|
uint8_t i = 1;
|
|
while (strstr(token, "\"")) {
|
|
token += strcspn(token, "\"") + 1;
|
|
token[strcspn(token, "\"")] = 0;
|
|
rfcomm->hf_indicators[i] = strdup(token);
|
|
token += strcspn(token, "\"") + 1;
|
|
i++;
|
|
if (i == MAX_HF_INDICATORS) {
|
|
break;
|
|
}
|
|
}
|
|
} else if (spa_strstartswith(token, "+CIND: ")) {
|
|
token[strcspn(token, "\r")] = 0;
|
|
token[strcspn(token, "\n")] = 0;
|
|
token += strlen("+CIND: ");
|
|
uint8_t i = 1;
|
|
while (strlen(token)) {
|
|
if (i >= MAX_HF_INDICATORS || !rfcomm->hf_indicators[i]) {
|
|
break;
|
|
}
|
|
token[strcspn(token, ",")] = 0;
|
|
spa_log_info(backend->log, "AG indicator state: %s = %i", rfcomm->hf_indicators[i], atoi(token));
|
|
|
|
if (spa_streq(rfcomm->hf_indicators[i], "battchg")) {
|
|
spa_bt_device_report_battery_level(rfcomm->device, atoi(token) * 100 / 5);
|
|
}
|
|
|
|
token += strcspn(token, "\0") + 1;
|
|
i++;
|
|
}
|
|
} else if (sscanf(token, "+CIEV: %u,%u", &indicator, &value) == 2) {
|
|
if (indicator >= MAX_HF_INDICATORS || !rfcomm->hf_indicators[indicator]) {
|
|
spa_log_warn(backend->log, "indicator %u has not been registered, ignoring", indicator);
|
|
} else {
|
|
spa_log_info(backend->log, "AG indicator update: %s = %u", rfcomm->hf_indicators[indicator], value);
|
|
|
|
if (spa_streq(rfcomm->hf_indicators[indicator], "battchg")) {
|
|
spa_bt_device_report_battery_level(rfcomm->device, value * 100 / 5);
|
|
}
|
|
}
|
|
} else if (spa_strstartswith(token, "OK")) {
|
|
switch(rfcomm->hf_state) {
|
|
case hfp_hf_brsf:
|
|
if (rfcomm->codec_negotiation_supported) {
|
|
rfcomm_send_cmd(rfcomm, "AT+BAC=1,2");
|
|
rfcomm->hf_state = hfp_hf_bac;
|
|
} else {
|
|
rfcomm_send_cmd(rfcomm, "AT+CIND=?");
|
|
rfcomm->hf_state = hfp_hf_cind1;
|
|
}
|
|
break;
|
|
case hfp_hf_bac:
|
|
rfcomm_send_cmd(rfcomm, "AT+CIND=?");
|
|
rfcomm->hf_state = hfp_hf_cind1;
|
|
break;
|
|
case hfp_hf_cind1:
|
|
rfcomm_send_cmd(rfcomm, "AT+CIND?");
|
|
rfcomm->hf_state = hfp_hf_cind2;
|
|
break;
|
|
case hfp_hf_cind2:
|
|
rfcomm_send_cmd(rfcomm, "AT+CMER=3,0,0,1");
|
|
rfcomm->hf_state = hfp_hf_cmer;
|
|
break;
|
|
case hfp_hf_cmer:
|
|
rfcomm->hf_state = hfp_hf_slc1;
|
|
rfcomm->slc_configured = true;
|
|
if (!rfcomm->codec_negotiation_supported) {
|
|
rfcomm->transport = _transport_create(rfcomm);
|
|
if (rfcomm->transport == NULL) {
|
|
spa_log_warn(backend->log, "can't create transport: %m");
|
|
// TODO: We should manage the missing transport
|
|
} else {
|
|
rfcomm->transport->codec = HFP_AUDIO_CODEC_CVSD;
|
|
spa_bt_device_connect_profile(rfcomm->device, rfcomm->profile);
|
|
}
|
|
}
|
|
/* Report volume on SLC establishment */
|
|
if (rfcomm_send_volume_cmd(rfcomm, SPA_BT_VOLUME_ID_RX))
|
|
rfcomm->hf_state = hfp_hf_vgs;
|
|
break;
|
|
case hfp_hf_slc2:
|
|
if (rfcomm_send_volume_cmd(rfcomm, SPA_BT_VOLUME_ID_RX))
|
|
rfcomm->hf_state = hfp_hf_vgs;
|
|
break;
|
|
case hfp_hf_vgs:
|
|
rfcomm->hf_state = hfp_hf_slc1;
|
|
if (rfcomm_send_volume_cmd(rfcomm, SPA_BT_VOLUME_ID_TX))
|
|
rfcomm->hf_state = hfp_hf_vgm;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif
|
|
|
|
static void rfcomm_event(struct spa_source *source)
|
|
{
|
|
struct rfcomm *rfcomm = source->data;
|
|
struct impl *backend = rfcomm->backend;
|
|
|
|
if (source->rmask & (SPA_IO_HUP | SPA_IO_ERR)) {
|
|
spa_log_info(backend->log, "lost RFCOMM connection.");
|
|
rfcomm_free(rfcomm);
|
|
return;
|
|
}
|
|
|
|
if (source->rmask & SPA_IO_IN) {
|
|
char buf[512];
|
|
ssize_t len;
|
|
bool res = false;
|
|
|
|
len = read(source->fd, buf, 511);
|
|
if (len < 0) {
|
|
spa_log_error(backend->log, "RFCOMM read error: %s", strerror(errno));
|
|
return;
|
|
}
|
|
buf[len] = 0;
|
|
spa_log_debug(backend->log, "RFCOMM << %s", buf);
|
|
|
|
switch (rfcomm->profile) {
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HSP_NATIVE
|
|
case SPA_BT_PROFILE_HSP_HS:
|
|
res = rfcomm_hsp_ag(rfcomm, buf);
|
|
break;
|
|
case SPA_BT_PROFILE_HSP_AG:
|
|
res = rfcomm_hsp_hs(rfcomm, buf);
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
case SPA_BT_PROFILE_HFP_HF:
|
|
res = rfcomm_hfp_ag(rfcomm, buf);
|
|
break;
|
|
case SPA_BT_PROFILE_HFP_AG:
|
|
res = rfcomm_hfp_hf(rfcomm, buf);
|
|
break;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (!res) {
|
|
spa_log_debug(backend->log, "RFCOMM received unsupported command: %s", buf);
|
|
rfcomm_send_error(rfcomm, CMEE_OPERATION_NOT_SUPPORTED);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int sco_create_socket(struct impl *backend, struct spa_bt_adapter *adapter, bool msbc)
|
|
{
|
|
struct sockaddr_sco addr;
|
|
socklen_t len;
|
|
bdaddr_t src;
|
|
|
|
spa_autoclose int sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET | SOCK_NONBLOCK, BTPROTO_SCO);
|
|
if (sock < 0) {
|
|
spa_log_error(backend->log, "socket(SEQPACKET, SCO) %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
str2ba(adapter->address, &src);
|
|
|
|
len = sizeof(addr);
|
|
memset(&addr, 0, len);
|
|
addr.sco_family = AF_BLUETOOTH;
|
|
bacpy(&addr.sco_bdaddr, &src);
|
|
|
|
if (bind(sock, (struct sockaddr *) &addr, len) < 0) {
|
|
spa_log_error(backend->log, "bind(): %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
spa_log_debug(backend->log, "msbc=%d", (int)msbc);
|
|
if (msbc) {
|
|
/* set correct socket options for mSBC */
|
|
struct bt_voice voice_config;
|
|
memset(&voice_config, 0, sizeof(voice_config));
|
|
voice_config.setting = BT_VOICE_TRANSPARENT;
|
|
if (setsockopt(sock, SOL_BLUETOOTH, BT_VOICE, &voice_config, sizeof(voice_config)) < 0) {
|
|
spa_log_error(backend->log, "setsockopt(): %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return spa_steal_fd(sock);
|
|
}
|
|
|
|
static int sco_do_connect(struct spa_bt_transport *t)
|
|
{
|
|
struct impl *backend = SPA_CONTAINER_OF(t->backend, struct impl, this);
|
|
struct spa_bt_device *d = t->device;
|
|
struct transport_data *td = t->user_data;
|
|
struct sockaddr_sco addr;
|
|
int err;
|
|
|
|
spa_log_debug(backend->log, "transport %p: enter sco_do_connect, codec=%u",
|
|
t, t->codec);
|
|
|
|
td->err = -EIO;
|
|
|
|
if (d->adapter == NULL)
|
|
return -EIO;
|
|
|
|
spa_zero(addr);
|
|
addr.sco_family = AF_BLUETOOTH;
|
|
str2ba(d->address, &addr.sco_bdaddr);
|
|
|
|
for (int retry = 2;;) {
|
|
spa_autoclose int sock = sco_create_socket(backend, d->adapter, (t->codec == HFP_AUDIO_CODEC_MSBC));
|
|
if (sock < 0)
|
|
return -1;
|
|
|
|
spa_log_debug(backend->log, "transport %p: doing connect", t);
|
|
err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
|
|
if (err < 0 && errno == ECONNABORTED && retry-- > 0) {
|
|
spa_log_warn(backend->log, "connect(): %s. Remaining retry:%d",
|
|
strerror(errno), retry);
|
|
continue;
|
|
} else if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS)) {
|
|
spa_log_error(backend->log, "connect(): %s", strerror(errno));
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
if (errno == EOPNOTSUPP && t->codec == HFP_AUDIO_CODEC_MSBC &&
|
|
td->rfcomm->msbc_supported_by_hfp) {
|
|
/* Adapter doesn't support msbc. Renegotiate. */
|
|
d->adapter->msbc_probed = true;
|
|
d->adapter->has_msbc = false;
|
|
td->rfcomm->msbc_supported_by_hfp = false;
|
|
if (t->profile == SPA_BT_PROFILE_HFP_HF) {
|
|
td->rfcomm->hfp_ag_switching_codec = true;
|
|
rfcomm_send_reply(td->rfcomm, "+BCS: 1");
|
|
} else if (t->profile == SPA_BT_PROFILE_HFP_AG) {
|
|
rfcomm_send_cmd(td->rfcomm, "AT+BAC=1");
|
|
}
|
|
}
|
|
#endif
|
|
return -1;
|
|
}
|
|
|
|
td->err = -EINPROGRESS;
|
|
|
|
return spa_steal_fd(sock);
|
|
}
|
|
}
|
|
|
|
static int rfcomm_ag_sync_volume(struct rfcomm *rfcomm, bool later);
|
|
|
|
static void sco_ready(struct spa_bt_transport *t)
|
|
{
|
|
struct impl *backend = SPA_CONTAINER_OF(t->backend, struct impl, this);
|
|
struct transport_data *td = t->user_data;
|
|
struct sco_options sco_opt;
|
|
socklen_t len;
|
|
int err;
|
|
|
|
spa_log_debug(backend->log, "transport %p: ready", t);
|
|
|
|
/* Read socket error status */
|
|
if (t->fd >= 0) {
|
|
if (td->err == -EINPROGRESS) {
|
|
len = sizeof(err);
|
|
memset(&err, 0, len);
|
|
if (getsockopt(t->fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
|
|
td->err = -errno;
|
|
else
|
|
td->err = -err;
|
|
}
|
|
} else {
|
|
td->err = -EIO;
|
|
}
|
|
|
|
if (!td->requesting)
|
|
return;
|
|
|
|
td->requesting = false;
|
|
|
|
if (td->err)
|
|
goto done;
|
|
|
|
/* XXX: The MTU as currently reported by kernel (6.2) here is not a valid packet size,
|
|
* XXX: for USB adapters, see sco-io.
|
|
*/
|
|
len = sizeof(sco_opt);
|
|
memset(&sco_opt, 0, len);
|
|
if (getsockopt(t->fd, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
|
|
spa_log_warn(backend->log, "getsockopt(SCO_OPTIONS) failed, using defaults");
|
|
t->read_mtu = 48;
|
|
t->write_mtu = 48;
|
|
} else {
|
|
spa_log_debug(backend->log, "autodetected mtu = %u", sco_opt.mtu);
|
|
t->read_mtu = sco_opt.mtu;
|
|
t->write_mtu = sco_opt.mtu;
|
|
}
|
|
|
|
/* Clear nonblocking flag we set for connect() */
|
|
err = fcntl(t->fd, F_GETFL, O_NONBLOCK);
|
|
if (err < 0) {
|
|
td->err = -errno;
|
|
goto done;
|
|
}
|
|
err &= ~O_NONBLOCK;
|
|
err = fcntl(t->fd, F_SETFL, O_NONBLOCK, err);
|
|
if (err < 0) {
|
|
td->err = -errno;
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
if (td->err) {
|
|
spa_log_debug(backend->log, "transport %p: acquire failed: %s (%d)",
|
|
t, strerror(-td->err), td->err);
|
|
spa_bt_transport_set_state(t, SPA_BT_TRANSPORT_STATE_ERROR);
|
|
return;
|
|
}
|
|
|
|
spa_log_debug(backend->log, "transport %p: acquire complete, read_mtu=%u, write_mtu=%u",
|
|
t, t->read_mtu, t->write_mtu);
|
|
|
|
/*
|
|
* Send RFCOMM volume after connection is ready, and also after
|
|
* a timeout.
|
|
*
|
|
* Some headsets adjust their HFP volume when in A2DP mode
|
|
* without reporting via RFCOMM to us, so the volume level can
|
|
* be out of sync, and we can't know what it is. Moreover, they may
|
|
* take the first +VGS command after connection only partially
|
|
* into account, and need a long enough timeout.
|
|
*
|
|
* E.g. with Sennheiser HD-250BT, the first +VGS changes the
|
|
* actual volume, but does not update the level in the hardware
|
|
* volume buttons, which is updated by an +VGS event only after
|
|
* sufficient time is elapsed from the connection.
|
|
*/
|
|
rfcomm_ag_sync_volume(td->rfcomm, false);
|
|
rfcomm_ag_sync_volume(td->rfcomm, true);
|
|
|
|
spa_bt_transport_set_state(t, SPA_BT_TRANSPORT_STATE_ACTIVE);
|
|
}
|
|
|
|
static void sco_start_source(struct spa_bt_transport *t);
|
|
|
|
static int sco_acquire_cb(void *data, bool optional)
|
|
{
|
|
struct spa_bt_transport *t = data;
|
|
struct transport_data *td = t->user_data;
|
|
struct impl *backend = SPA_CONTAINER_OF(t->backend, struct impl, this);
|
|
int sock;
|
|
|
|
spa_log_debug(backend->log, "transport %p: enter sco_acquire_cb", t);
|
|
|
|
if (optional || t->fd > 0)
|
|
sock = t->fd;
|
|
else
|
|
sock = sco_do_connect(t);
|
|
|
|
if (sock < 0)
|
|
goto fail;
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
rfcomm_hfp_ag_set_cind(td->rfcomm, true);
|
|
#endif
|
|
|
|
t->fd = sock;
|
|
|
|
td->requesting = true;
|
|
|
|
sco_start_source(t);
|
|
|
|
if (td->err != -EINPROGRESS)
|
|
sco_ready(t);
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
spa_bt_transport_set_state(t, SPA_BT_TRANSPORT_STATE_ERROR);
|
|
return -1;
|
|
}
|
|
|
|
static int sco_destroy_cb(void *data)
|
|
{
|
|
struct spa_bt_transport *t = data;
|
|
struct transport_data *td = t->user_data;
|
|
struct impl *backend = SPA_CONTAINER_OF(t->backend, struct impl, this);
|
|
|
|
if (t->sco_io) {
|
|
spa_bt_sco_io_destroy(t->sco_io);
|
|
t->sco_io = NULL;
|
|
}
|
|
|
|
if (td->sco.loop)
|
|
spa_loop_remove_source(backend->main_loop, &td->sco);
|
|
|
|
if (t->fd > 0) {
|
|
/* Shutdown and close the socket */
|
|
shutdown(t->fd, SHUT_RDWR);
|
|
close(t->fd);
|
|
t->fd = -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sco_release_cb(void *data)
|
|
{
|
|
struct spa_bt_transport *t = data;
|
|
struct transport_data *td = t->user_data;
|
|
struct impl *backend = SPA_CONTAINER_OF(t->backend, struct impl, this);
|
|
|
|
spa_log_info(backend->log, "Transport %s released", t->path);
|
|
|
|
spa_bt_transport_set_state(t, SPA_BT_TRANSPORT_STATE_IDLE);
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
rfcomm_hfp_ag_set_cind(td->rfcomm, false);
|
|
#endif
|
|
|
|
sco_destroy_cb(t);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void sco_event(struct spa_source *source)
|
|
{
|
|
struct spa_bt_transport *t = source->data;
|
|
struct impl *backend = SPA_CONTAINER_OF(t->backend, struct impl, this);
|
|
|
|
if (source->rmask & (SPA_IO_HUP | SPA_IO_ERR)) {
|
|
spa_log_debug(backend->log, "transport %p: error on SCO socket: %s", t, strerror(errno));
|
|
sco_ready(t);
|
|
if (source->loop)
|
|
spa_loop_remove_source(source->loop, source);
|
|
if (t->fd >= 0) {
|
|
spa_bt_transport_set_state(t, SPA_BT_TRANSPORT_STATE_IDLE);
|
|
shutdown(t->fd, SHUT_RDWR);
|
|
close(t->fd);
|
|
t->fd = -1;
|
|
}
|
|
}
|
|
|
|
if (source->rmask & SPA_IO_IN) {
|
|
SPA_FLAG_UPDATE(source->mask, SPA_IO_IN, false);
|
|
spa_loop_update_source(backend->main_loop, source);
|
|
sco_ready(t);
|
|
}
|
|
}
|
|
|
|
static void sco_start_source(struct spa_bt_transport *t)
|
|
{
|
|
struct impl *backend = SPA_CONTAINER_OF(t->backend, struct impl, this);
|
|
struct transport_data *td = t->user_data;
|
|
|
|
if (td->sco.loop)
|
|
return;
|
|
|
|
td->err = -EINPROGRESS;
|
|
|
|
/*
|
|
* We on purpose wait for POLLIN when connecting (not POLLOUT as usual), to
|
|
* indicate ready only after we are sure the device is sending data.
|
|
*/
|
|
td->sco.func = sco_event;
|
|
td->sco.data = t;
|
|
td->sco.fd = t->fd;
|
|
td->sco.mask = SPA_IO_HUP | SPA_IO_ERR | SPA_IO_IN;
|
|
td->sco.rmask = 0;
|
|
spa_loop_add_source(backend->main_loop, &td->sco);
|
|
}
|
|
|
|
static void sco_listen_event(struct spa_source *source)
|
|
{
|
|
struct impl *backend = source->data;
|
|
struct sockaddr_sco addr;
|
|
socklen_t addrlen;
|
|
char local_address[18], remote_address[18];
|
|
struct rfcomm *rfcomm;
|
|
struct spa_bt_transport *t = NULL;
|
|
|
|
if (source->rmask & (SPA_IO_HUP | SPA_IO_ERR)) {
|
|
spa_log_error(backend->log, "error listening SCO connection: %s", strerror(errno));
|
|
return;
|
|
}
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
addrlen = sizeof(addr);
|
|
|
|
spa_log_debug(backend->log, "doing accept");
|
|
spa_autoclose int sock = accept(source->fd, (struct sockaddr *) &addr, &addrlen);
|
|
if (sock < 0) {
|
|
if (errno != EAGAIN)
|
|
spa_log_error(backend->log, "SCO accept(): %s", strerror(errno));
|
|
return;
|
|
}
|
|
|
|
ba2str(&addr.sco_bdaddr, remote_address);
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
addrlen = sizeof(addr);
|
|
|
|
if (getsockname(sock, (struct sockaddr *) &addr, &addrlen) < 0) {
|
|
spa_log_error(backend->log, "SCO getsockname(): %s", strerror(errno));
|
|
return;
|
|
}
|
|
|
|
ba2str(&addr.sco_bdaddr, local_address);
|
|
|
|
/* Find transport for local and remote address */
|
|
spa_list_for_each(rfcomm, &backend->rfcomm_list, link) {
|
|
if (rfcomm->transport && spa_streq(rfcomm->transport->device->address, remote_address) &&
|
|
spa_streq(rfcomm->transport->device->adapter->address, local_address)) {
|
|
t = rfcomm->transport;
|
|
break;
|
|
}
|
|
}
|
|
if (!t) {
|
|
spa_log_debug(backend->log, "No transport for adapter %s and remote %s",
|
|
local_address, remote_address);
|
|
return;
|
|
}
|
|
|
|
/* The Synchronous Connection shall always be established by the AG, i.e. the remote profile
|
|
should be a HSP AG or HFP AG profile */
|
|
if ((t->profile & SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY) == 0) {
|
|
spa_log_debug(backend->log, "transport %p: Rejecting incoming audio connection to an AG profile", t);
|
|
return;
|
|
}
|
|
|
|
if (t->fd >= 0) {
|
|
spa_log_debug(backend->log, "transport %p: Rejecting, audio already connected", t);
|
|
return;
|
|
}
|
|
|
|
spa_log_debug(backend->log, "transport %p: codec=%u", t, t->codec);
|
|
if (backend->defer_setup_enabled) {
|
|
/* In BT_DEFER_SETUP mode, when a connection is accepted, the listening socket is unblocked but
|
|
* the effective connection setup happens only on first receive, allowing to configure the
|
|
* accepted socket. */
|
|
char buff;
|
|
|
|
if (t->codec == HFP_AUDIO_CODEC_MSBC) {
|
|
/* set correct socket options for mSBC */
|
|
struct bt_voice voice_config;
|
|
memset(&voice_config, 0, sizeof(voice_config));
|
|
voice_config.setting = BT_VOICE_TRANSPARENT;
|
|
if (setsockopt(sock, SOL_BLUETOOTH, BT_VOICE, &voice_config, sizeof(voice_config)) < 0) {
|
|
spa_log_error(backend->log, "transport %p: setsockopt(): %s", t, strerror(errno));
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* First read from the accepted socket is non-blocking and returns a zero length buffer. */
|
|
if (read(sock, &buff, 1) == -1) {
|
|
spa_log_error(backend->log, "transport %p: Couldn't authorize SCO connection: %s", t, strerror(errno));
|
|
return;
|
|
}
|
|
}
|
|
|
|
t->fd = spa_steal_fd(sock);
|
|
|
|
sco_start_source(t);
|
|
|
|
spa_log_debug(backend->log, "transport %p: audio connected", t);
|
|
|
|
/* Report initial volume to remote */
|
|
if (t->profile == SPA_BT_PROFILE_HSP_AG) {
|
|
if (rfcomm_send_volume_cmd(rfcomm, SPA_BT_VOLUME_ID_RX))
|
|
rfcomm->hs_state = hsp_hs_vgs;
|
|
else
|
|
rfcomm->hs_state = hsp_hs_init1;
|
|
} else if (t->profile == SPA_BT_PROFILE_HFP_AG) {
|
|
if (rfcomm_send_volume_cmd(rfcomm, SPA_BT_VOLUME_ID_RX))
|
|
rfcomm->hf_state = hfp_hf_vgs;
|
|
else
|
|
rfcomm->hf_state = hfp_hf_slc1;
|
|
}
|
|
|
|
spa_bt_transport_set_state(t, SPA_BT_TRANSPORT_STATE_PENDING);
|
|
}
|
|
|
|
static void sco_listen(struct impl *backend)
|
|
{
|
|
struct sockaddr_sco addr;
|
|
uint32_t defer = 1;
|
|
|
|
spa_autoclose int sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET | SOCK_NONBLOCK | SOCK_CLOEXEC, BTPROTO_SCO);
|
|
if (sock < 0) {
|
|
spa_log_error(backend->log, "socket(SEQPACKET, SCO) %m");
|
|
return;
|
|
}
|
|
|
|
/* Bind to local address */
|
|
memset(&addr, 0, sizeof(addr));
|
|
addr.sco_family = AF_BLUETOOTH;
|
|
bacpy(&addr.sco_bdaddr, BDADDR_ANY);
|
|
|
|
if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
|
|
spa_log_error(backend->log, "bind(): %m");
|
|
return;
|
|
}
|
|
|
|
if (setsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP, &defer, sizeof(defer)) < 0) {
|
|
spa_log_warn(backend->log, "Can't enable deferred setup: %s", strerror(errno));
|
|
backend->defer_setup_enabled = 0;
|
|
} else {
|
|
backend->defer_setup_enabled = 1;
|
|
}
|
|
|
|
spa_log_debug(backend->log, "doing listen");
|
|
if (listen(sock, 1) < 0) {
|
|
spa_log_error(backend->log, "listen(): %m");
|
|
return;
|
|
}
|
|
|
|
backend->sco.func = sco_listen_event;
|
|
backend->sco.data = backend;
|
|
backend->sco.fd = spa_steal_fd(sock);
|
|
backend->sco.mask = SPA_IO_IN;
|
|
backend->sco.rmask = 0;
|
|
spa_loop_add_source(backend->main_loop, &backend->sco);
|
|
|
|
return;
|
|
}
|
|
|
|
static int rfcomm_ag_set_volume(struct spa_bt_transport *t, int id)
|
|
{
|
|
struct transport_data *td = t->user_data;
|
|
struct rfcomm *rfcomm = td->rfcomm;
|
|
const char *format;
|
|
int value;
|
|
|
|
if (!rfcomm_volume_enabled(rfcomm)
|
|
|| !(rfcomm->profile & SPA_BT_PROFILE_HEADSET_HEAD_UNIT)
|
|
|| !(rfcomm->has_volume && rfcomm->volumes[id].active))
|
|
return -ENOTSUP;
|
|
|
|
value = rfcomm->volumes[id].hw_volume;
|
|
|
|
if (id == SPA_BT_VOLUME_ID_RX)
|
|
if (rfcomm->profile & SPA_BT_PROFILE_HFP_HF)
|
|
format = "+VGM: %d";
|
|
else
|
|
format = "+VGM=%d";
|
|
else if (id == SPA_BT_VOLUME_ID_TX)
|
|
if (rfcomm->profile & SPA_BT_PROFILE_HFP_HF)
|
|
format = "+VGS: %d";
|
|
else
|
|
format = "+VGS=%d";
|
|
else
|
|
spa_assert_not_reached();
|
|
|
|
if (rfcomm->transport)
|
|
rfcomm_send_reply(rfcomm, format, value);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sco_set_volume_cb(void *data, int id, float volume)
|
|
{
|
|
struct spa_bt_transport *t = data;
|
|
struct spa_bt_transport_volume *t_volume = &t->volumes[id];
|
|
struct transport_data *td = t->user_data;
|
|
struct rfcomm *rfcomm = td->rfcomm;
|
|
int value;
|
|
|
|
if (!rfcomm_volume_enabled(rfcomm)
|
|
|| !(rfcomm->profile & SPA_BT_PROFILE_HEADSET_HEAD_UNIT)
|
|
|| !(rfcomm->has_volume && rfcomm->volumes[id].active))
|
|
return -ENOTSUP;
|
|
|
|
value = spa_bt_volume_linear_to_hw(volume, t_volume->hw_volume_max);
|
|
t_volume->volume = volume;
|
|
|
|
if (rfcomm->volumes[id].hw_volume == value)
|
|
return 0;
|
|
rfcomm->volumes[id].hw_volume = value;
|
|
|
|
return rfcomm_ag_set_volume(t, id);
|
|
}
|
|
|
|
static const struct spa_bt_transport_implementation sco_transport_impl = {
|
|
SPA_VERSION_BT_TRANSPORT_IMPLEMENTATION,
|
|
.acquire = sco_acquire_cb,
|
|
.release = sco_release_cb,
|
|
.set_volume = sco_set_volume_cb,
|
|
.destroy = sco_destroy_cb,
|
|
};
|
|
|
|
static struct rfcomm *device_find_rfcomm(struct impl *backend, struct spa_bt_device *device)
|
|
{
|
|
struct rfcomm *rfcomm;
|
|
spa_list_for_each(rfcomm, &backend->rfcomm_list, link) {
|
|
if (rfcomm->device == device)
|
|
return rfcomm;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int backend_native_supports_codec(void *data, struct spa_bt_device *device, unsigned int codec)
|
|
{
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
struct impl *backend = data;
|
|
struct rfcomm *rfcomm;
|
|
|
|
rfcomm = device_find_rfcomm(backend, device);
|
|
if (rfcomm == NULL || rfcomm->profile != SPA_BT_PROFILE_HFP_HF)
|
|
return -ENOTSUP;
|
|
|
|
if (codec == HFP_AUDIO_CODEC_CVSD)
|
|
return 1;
|
|
|
|
return (codec == HFP_AUDIO_CODEC_MSBC &&
|
|
(rfcomm->profile == SPA_BT_PROFILE_HFP_AG ||
|
|
rfcomm->profile == SPA_BT_PROFILE_HFP_HF) &&
|
|
rfcomm->msbc_supported_by_hfp &&
|
|
rfcomm->codec_negotiation_supported) ? 1 : 0;
|
|
#else
|
|
return -ENOTSUP;
|
|
#endif
|
|
}
|
|
|
|
static int codec_switch_stop_timer(struct rfcomm *rfcomm)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
struct itimerspec ts;
|
|
|
|
if (rfcomm->timer.data == NULL)
|
|
return 0;
|
|
|
|
spa_loop_remove_source(backend->main_loop, &rfcomm->timer);
|
|
ts.it_value.tv_sec = 0;
|
|
ts.it_value.tv_nsec = 0;
|
|
ts.it_interval.tv_sec = 0;
|
|
ts.it_interval.tv_nsec = 0;
|
|
spa_system_timerfd_settime(backend->main_system, rfcomm->timer.fd, 0, &ts, NULL);
|
|
spa_system_close(backend->main_system, rfcomm->timer.fd);
|
|
rfcomm->timer.data = NULL;
|
|
return 0;
|
|
}
|
|
|
|
static void volume_sync_stop_timer(struct rfcomm *rfcomm)
|
|
{
|
|
if (rfcomm->volume_sync_timer)
|
|
spa_loop_utils_update_timer(rfcomm->backend->loop_utils, rfcomm->volume_sync_timer,
|
|
NULL, NULL, false);
|
|
}
|
|
|
|
static void volume_sync_timer_event(void *data, uint64_t expirations)
|
|
{
|
|
struct rfcomm *rfcomm = data;
|
|
|
|
volume_sync_stop_timer(rfcomm);
|
|
|
|
if (rfcomm->transport) {
|
|
rfcomm_ag_set_volume(rfcomm->transport, SPA_BT_VOLUME_ID_TX);
|
|
rfcomm_ag_set_volume(rfcomm->transport, SPA_BT_VOLUME_ID_RX);
|
|
}
|
|
}
|
|
|
|
static int volume_sync_start_timer(struct rfcomm *rfcomm)
|
|
{
|
|
struct timespec ts;
|
|
const uint64_t timeout = 1500 * SPA_NSEC_PER_MSEC;
|
|
|
|
if (rfcomm->volume_sync_timer == NULL)
|
|
rfcomm->volume_sync_timer = spa_loop_utils_add_timer(rfcomm->backend->loop_utils,
|
|
volume_sync_timer_event, rfcomm);
|
|
|
|
if (rfcomm->volume_sync_timer == NULL)
|
|
return -EIO;
|
|
|
|
ts.tv_sec = timeout / SPA_NSEC_PER_SEC;
|
|
ts.tv_nsec = timeout % SPA_NSEC_PER_SEC;
|
|
spa_loop_utils_update_timer(rfcomm->backend->loop_utils, rfcomm->volume_sync_timer,
|
|
&ts, NULL, false);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int rfcomm_ag_sync_volume(struct rfcomm *rfcomm, bool later)
|
|
{
|
|
if (rfcomm->transport == NULL)
|
|
return -ENOENT;
|
|
|
|
if (!later) {
|
|
rfcomm_ag_set_volume(rfcomm->transport, SPA_BT_VOLUME_ID_TX);
|
|
rfcomm_ag_set_volume(rfcomm->transport, SPA_BT_VOLUME_ID_RX);
|
|
} else {
|
|
volume_sync_start_timer(rfcomm);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void codec_switch_timer_event(struct spa_source *source)
|
|
{
|
|
struct rfcomm *rfcomm = source->data;
|
|
struct impl *backend = rfcomm->backend;
|
|
uint64_t exp;
|
|
|
|
if (spa_system_timerfd_read(backend->main_system, source->fd, &exp) < 0)
|
|
spa_log_warn(backend->log, "error reading timerfd: %s", strerror(errno));
|
|
|
|
codec_switch_stop_timer(rfcomm);
|
|
|
|
spa_log_debug(backend->log, "rfcomm %p: codec switch timeout", rfcomm);
|
|
|
|
switch (rfcomm->hfp_ag_initial_codec_setup) {
|
|
case HFP_AG_INITIAL_CODEC_SETUP_SEND:
|
|
/* Retry codec selection */
|
|
rfcomm->hfp_ag_initial_codec_setup = HFP_AG_INITIAL_CODEC_SETUP_WAIT;
|
|
rfcomm_send_reply(rfcomm, "+BCS: 2");
|
|
codec_switch_start_timer(rfcomm, HFP_CODEC_SWITCH_TIMEOUT_MSEC);
|
|
return;
|
|
case HFP_AG_INITIAL_CODEC_SETUP_WAIT:
|
|
/* Failure, try falling back to CVSD. */
|
|
rfcomm->hfp_ag_initial_codec_setup = HFP_AG_INITIAL_CODEC_SETUP_NONE;
|
|
if (rfcomm->transport == NULL) {
|
|
rfcomm->transport = _transport_create(rfcomm);
|
|
if (rfcomm->transport == NULL) {
|
|
spa_log_warn(backend->log, "can't create transport: %m");
|
|
} else {
|
|
rfcomm->transport->codec = HFP_AUDIO_CODEC_CVSD;
|
|
spa_bt_device_connect_profile(rfcomm->device, rfcomm->profile);
|
|
}
|
|
}
|
|
rfcomm_send_reply(rfcomm, "+BCS: 1");
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (rfcomm->hfp_ag_switching_codec) {
|
|
rfcomm->hfp_ag_switching_codec = false;
|
|
if (rfcomm->device)
|
|
spa_bt_device_emit_codec_switched(rfcomm->device, -EIO);
|
|
}
|
|
}
|
|
|
|
static int codec_switch_start_timer(struct rfcomm *rfcomm, int timeout_msec)
|
|
{
|
|
struct impl *backend = rfcomm->backend;
|
|
struct itimerspec ts;
|
|
|
|
spa_log_debug(backend->log, "rfcomm %p: start timer", rfcomm);
|
|
if (rfcomm->timer.data == NULL) {
|
|
rfcomm->timer.data = rfcomm;
|
|
rfcomm->timer.func = codec_switch_timer_event;
|
|
rfcomm->timer.fd = spa_system_timerfd_create(backend->main_system,
|
|
CLOCK_MONOTONIC, SPA_FD_CLOEXEC | SPA_FD_NONBLOCK);
|
|
rfcomm->timer.mask = SPA_IO_IN;
|
|
rfcomm->timer.rmask = 0;
|
|
spa_loop_add_source(backend->main_loop, &rfcomm->timer);
|
|
}
|
|
ts.it_value.tv_sec = timeout_msec / SPA_MSEC_PER_SEC;
|
|
ts.it_value.tv_nsec = (timeout_msec % SPA_MSEC_PER_SEC) * SPA_NSEC_PER_MSEC;
|
|
ts.it_interval.tv_sec = 0;
|
|
ts.it_interval.tv_nsec = 0;
|
|
spa_system_timerfd_settime(backend->main_system, rfcomm->timer.fd, 0, &ts, NULL);
|
|
return 0;
|
|
}
|
|
|
|
static int backend_native_ensure_codec(void *data, struct spa_bt_device *device, unsigned int codec)
|
|
{
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
struct impl *backend = data;
|
|
struct rfcomm *rfcomm;
|
|
int res;
|
|
|
|
res = backend_native_supports_codec(data, device, codec);
|
|
if (res <= 0)
|
|
return -EINVAL;
|
|
|
|
rfcomm = device_find_rfcomm(backend, device);
|
|
if (rfcomm == NULL)
|
|
return -ENOTSUP;
|
|
|
|
if (!rfcomm->codec_negotiation_supported)
|
|
return -ENOTSUP;
|
|
|
|
if (rfcomm->codec == codec) {
|
|
spa_bt_device_emit_codec_switched(device, 0);
|
|
return 0;
|
|
}
|
|
|
|
if ((res = rfcomm_send_reply(rfcomm, "+BCS: %u", codec)) < 0)
|
|
return res;
|
|
|
|
rfcomm->hfp_ag_switching_codec = true;
|
|
codec_switch_start_timer(rfcomm, HFP_CODEC_SWITCH_TIMEOUT_MSEC);
|
|
|
|
return 0;
|
|
#else
|
|
return -ENOTSUP;
|
|
#endif
|
|
}
|
|
|
|
static void device_destroy(void *data)
|
|
{
|
|
struct rfcomm *rfcomm = data;
|
|
rfcomm_free(rfcomm);
|
|
}
|
|
|
|
static const struct spa_bt_device_events device_events = {
|
|
SPA_VERSION_BT_DEVICE_EVENTS,
|
|
.destroy = device_destroy,
|
|
};
|
|
|
|
static enum spa_bt_profile path_to_profile(const char *path)
|
|
{
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HSP_NATIVE
|
|
if (spa_streq(path, PROFILE_HSP_AG))
|
|
return SPA_BT_PROFILE_HSP_HS;
|
|
|
|
if (spa_streq(path, PROFILE_HSP_HS))
|
|
return SPA_BT_PROFILE_HSP_AG;
|
|
#endif
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
if (spa_streq(path, PROFILE_HFP_AG))
|
|
return SPA_BT_PROFILE_HFP_HF;
|
|
|
|
if (spa_streq(path, PROFILE_HFP_HF))
|
|
return SPA_BT_PROFILE_HFP_AG;
|
|
#endif
|
|
|
|
return SPA_BT_PROFILE_NULL;
|
|
}
|
|
|
|
static DBusHandlerResult profile_new_connection(DBusConnection *conn, DBusMessage *m, void *userdata)
|
|
{
|
|
struct impl *backend = userdata;
|
|
spa_autoptr(DBusMessage) r = NULL;
|
|
DBusMessageIter it;
|
|
const char *handler, *path;
|
|
enum spa_bt_profile profile;
|
|
struct rfcomm *rfcomm;
|
|
struct spa_bt_device *d;
|
|
struct spa_bt_transport *t = NULL;
|
|
spa_autoclose int fd = -1;
|
|
|
|
if (!dbus_message_has_signature(m, "oha{sv}")) {
|
|
spa_log_warn(backend->log, "invalid NewConnection() signature");
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
handler = dbus_message_get_path(m);
|
|
profile = path_to_profile(handler);
|
|
if (profile == SPA_BT_PROFILE_NULL) {
|
|
spa_log_warn(backend->log, "invalid handler %s", handler);
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
dbus_message_iter_init(m, &it);
|
|
dbus_message_iter_get_basic(&it, &path);
|
|
|
|
d = spa_bt_device_find(backend->monitor, path);
|
|
if (d == NULL || d->adapter == NULL) {
|
|
spa_log_warn(backend->log, "unknown device for path %s", path);
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
spa_bt_device_add_profile(d, profile);
|
|
|
|
dbus_message_iter_next(&it);
|
|
dbus_message_iter_get_basic(&it, &fd);
|
|
|
|
spa_log_debug(backend->log, "NewConnection path=%s, fd=%d, profile %s", path, fd, handler);
|
|
|
|
rfcomm = calloc(1, sizeof(struct rfcomm));
|
|
if (rfcomm == NULL)
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
|
|
rfcomm->backend = backend;
|
|
rfcomm->profile = profile;
|
|
rfcomm->device = d;
|
|
rfcomm->path = strdup(path);
|
|
rfcomm->source.func = rfcomm_event;
|
|
rfcomm->source.data = rfcomm;
|
|
rfcomm->source.fd = spa_steal_fd(fd);
|
|
rfcomm->source.mask = SPA_IO_IN;
|
|
rfcomm->source.rmask = 0;
|
|
/* By default all indicators are enabled */
|
|
rfcomm->cind_enabled_indicators = 0xFFFFFFFF;
|
|
memset(rfcomm->hf_indicators, 0, sizeof rfcomm->hf_indicators);
|
|
|
|
for (int i = 0; i < SPA_BT_VOLUME_ID_TERM; ++i) {
|
|
if (rfcomm->profile & SPA_BT_PROFILE_HEADSET_AUDIO_GATEWAY)
|
|
rfcomm->volumes[i].active = true;
|
|
rfcomm->volumes[i].hw_volume = SPA_BT_VOLUME_INVALID;
|
|
}
|
|
|
|
spa_bt_device_add_listener(d, &rfcomm->device_listener, &device_events, rfcomm);
|
|
spa_loop_add_source(backend->main_loop, &rfcomm->source);
|
|
spa_list_append(&backend->rfcomm_list, &rfcomm->link);
|
|
|
|
if (profile == SPA_BT_PROFILE_HSP_HS || profile == SPA_BT_PROFILE_HSP_AG) {
|
|
t = _transport_create(rfcomm);
|
|
if (t == NULL) {
|
|
spa_log_warn(backend->log, "can't create transport: %m");
|
|
goto fail_need_memory;
|
|
}
|
|
rfcomm->transport = t;
|
|
rfcomm->has_volume = rfcomm_volume_enabled(rfcomm);
|
|
|
|
if (profile == SPA_BT_PROFILE_HSP_AG) {
|
|
rfcomm->hs_state = hsp_hs_init1;
|
|
}
|
|
|
|
spa_bt_device_connect_profile(t->device, profile);
|
|
|
|
spa_log_debug(backend->log, "Transport %s available for profile %s", t->path, handler);
|
|
} else if (profile == SPA_BT_PROFILE_HFP_AG) {
|
|
/* Start SLC connection */
|
|
unsigned int hf_features = SPA_BT_HFP_HF_FEATURE_NONE;
|
|
|
|
/* Decide if we want to signal that the HF supports mSBC negotiation
|
|
This should be done when the bluetooth adapter supports the necessary transport mode */
|
|
if (device_supports_required_mSBC_transport_modes(backend, rfcomm->device)) {
|
|
/* set the feature bit that indicates HF supports codec negotiation */
|
|
hf_features |= SPA_BT_HFP_HF_FEATURE_CODEC_NEGOTIATION;
|
|
rfcomm->msbc_supported_by_hfp = true;
|
|
rfcomm->codec_negotiation_supported = false;
|
|
} else {
|
|
rfcomm->msbc_supported_by_hfp = false;
|
|
rfcomm->codec_negotiation_supported = false;
|
|
}
|
|
|
|
if (rfcomm_volume_enabled(rfcomm)) {
|
|
rfcomm->has_volume = true;
|
|
hf_features |= SPA_BT_HFP_HF_FEATURE_REMOTE_VOLUME_CONTROL;
|
|
}
|
|
|
|
/* send command to AG with the features supported by Hands-Free */
|
|
rfcomm_send_cmd(rfcomm, "AT+BRSF=%u", hf_features);
|
|
|
|
rfcomm->hf_state = hfp_hf_brsf;
|
|
}
|
|
|
|
if (rfcomm_volume_enabled(rfcomm) && (profile == SPA_BT_PROFILE_HFP_HF || profile == SPA_BT_PROFILE_HSP_HS)) {
|
|
uint32_t device_features;
|
|
if (spa_bt_quirks_get_features(backend->quirks, d->adapter, d, &device_features) == 0) {
|
|
rfcomm->broken_mic_hw_volume = !(device_features & SPA_BT_FEATURE_HW_VOLUME_MIC);
|
|
if (rfcomm->broken_mic_hw_volume)
|
|
spa_log_debug(backend->log, "microphone HW volume disabled by quirk");
|
|
}
|
|
}
|
|
|
|
if ((r = dbus_message_new_method_return(m)) == NULL)
|
|
goto fail_need_memory;
|
|
if (!dbus_connection_send(conn, r, NULL))
|
|
goto fail_need_memory;
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
|
|
fail_need_memory:
|
|
if (rfcomm)
|
|
rfcomm_free(rfcomm);
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
}
|
|
|
|
static DBusHandlerResult profile_request_disconnection(DBusConnection *conn, DBusMessage *m, void *userdata)
|
|
{
|
|
struct impl *backend = userdata;
|
|
spa_autoptr(DBusMessage) r = NULL;
|
|
const char *handler, *path;
|
|
struct spa_bt_device *d;
|
|
enum spa_bt_profile profile = SPA_BT_PROFILE_NULL;
|
|
DBusMessageIter it[5];
|
|
struct rfcomm *rfcomm, *rfcomm_tmp;
|
|
|
|
if (!dbus_message_has_signature(m, "o")) {
|
|
spa_log_warn(backend->log, "invalid RequestDisconnection() signature");
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
handler = dbus_message_get_path(m);
|
|
profile = path_to_profile(handler);
|
|
if (profile == SPA_BT_PROFILE_NULL) {
|
|
spa_log_warn(backend->log, "invalid handler %s", handler);
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
dbus_message_iter_init(m, &it[0]);
|
|
dbus_message_iter_get_basic(&it[0], &path);
|
|
|
|
d = spa_bt_device_find(backend->monitor, path);
|
|
if (d == NULL || d->adapter == NULL) {
|
|
spa_log_warn(backend->log, "unknown device for path %s", path);
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
spa_list_for_each_safe(rfcomm, rfcomm_tmp, &backend->rfcomm_list, link) {
|
|
if (rfcomm->device == d && rfcomm->profile == profile) {
|
|
rfcomm_free(rfcomm);
|
|
}
|
|
}
|
|
spa_bt_device_check_profiles(d, false);
|
|
|
|
if ((r = dbus_message_new_method_return(m)) == NULL)
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
if (!dbus_connection_send(conn, r, NULL))
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
|
|
static DBusHandlerResult profile_handler(DBusConnection *c, DBusMessage *m, void *userdata)
|
|
{
|
|
struct impl *backend = userdata;
|
|
const char *path, *interface, *member;
|
|
DBusHandlerResult res;
|
|
|
|
path = dbus_message_get_path(m);
|
|
interface = dbus_message_get_interface(m);
|
|
member = dbus_message_get_member(m);
|
|
|
|
spa_log_debug(backend->log, "dbus: path=%s, interface=%s, member=%s", path, interface, member);
|
|
|
|
if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
|
|
const char *xml = PROFILE_INTROSPECT_XML;
|
|
spa_autoptr(DBusMessage) r = NULL;
|
|
|
|
if ((r = dbus_message_new_method_return(m)) == NULL)
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
if (!dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID))
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
if (!dbus_connection_send(backend->conn, r, NULL))
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
|
|
res = DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "Release"))
|
|
res = profile_release(c, m, userdata);
|
|
else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "RequestDisconnection"))
|
|
res = profile_request_disconnection(c, m, userdata);
|
|
else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "NewConnection"))
|
|
res = profile_new_connection(c, m, userdata);
|
|
else
|
|
res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
|
|
return res;
|
|
}
|
|
|
|
static void register_profile_reply(DBusPendingCall *pending, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
|
|
spa_autoptr(DBusMessage) r = steal_reply_and_unref(&pending);
|
|
if (r == NULL)
|
|
return;
|
|
|
|
if (dbus_message_is_error(r, BLUEZ_ERROR_NOT_SUPPORTED)) {
|
|
spa_log_warn(backend->log, "Register profile not supported");
|
|
return;
|
|
}
|
|
if (dbus_message_is_error(r, DBUS_ERROR_UNKNOWN_METHOD)) {
|
|
spa_log_warn(backend->log, "Error registering profile");
|
|
return;
|
|
}
|
|
if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
|
|
spa_log_error(backend->log, "RegisterProfile() failed: %s",
|
|
dbus_message_get_error_name(r));
|
|
return;
|
|
}
|
|
}
|
|
|
|
static int register_profile(struct impl *backend, const char *profile, const char *uuid)
|
|
{
|
|
spa_autoptr(DBusMessage) m = NULL;
|
|
DBusMessageIter it[4];
|
|
dbus_bool_t autoconnect;
|
|
dbus_uint16_t version, chan, features;
|
|
const char *str;
|
|
|
|
if (!(backend->enabled_profiles & spa_bt_profile_from_uuid(uuid)))
|
|
return -ECANCELED;
|
|
|
|
spa_log_debug(backend->log, "Registering Profile %s %s", profile, uuid);
|
|
|
|
m = dbus_message_new_method_call(BLUEZ_SERVICE, "/org/bluez",
|
|
BLUEZ_PROFILE_MANAGER_INTERFACE, "RegisterProfile");
|
|
if (m == NULL)
|
|
return -ENOMEM;
|
|
|
|
dbus_message_iter_init_append(m, &it[0]);
|
|
dbus_message_iter_append_basic(&it[0], DBUS_TYPE_OBJECT_PATH, &profile);
|
|
dbus_message_iter_append_basic(&it[0], DBUS_TYPE_STRING, &uuid);
|
|
dbus_message_iter_open_container(&it[0], DBUS_TYPE_ARRAY, "{sv}", &it[1]);
|
|
|
|
if (spa_streq(uuid, SPA_BT_UUID_HSP_HS) ||
|
|
spa_streq(uuid, SPA_BT_UUID_HSP_HS_ALT)) {
|
|
|
|
/* In the headset role, the connection will only be initiated from the remote side */
|
|
str = "AutoConnect";
|
|
autoconnect = 0;
|
|
dbus_message_iter_open_container(&it[1], DBUS_TYPE_DICT_ENTRY, NULL, &it[2]);
|
|
dbus_message_iter_append_basic(&it[2], DBUS_TYPE_STRING, &str);
|
|
dbus_message_iter_open_container(&it[2], DBUS_TYPE_VARIANT, "b", &it[3]);
|
|
dbus_message_iter_append_basic(&it[3], DBUS_TYPE_BOOLEAN, &autoconnect);
|
|
dbus_message_iter_close_container(&it[2], &it[3]);
|
|
dbus_message_iter_close_container(&it[1], &it[2]);
|
|
|
|
str = "Channel";
|
|
chan = HSP_HS_DEFAULT_CHANNEL;
|
|
dbus_message_iter_open_container(&it[1], DBUS_TYPE_DICT_ENTRY, NULL, &it[2]);
|
|
dbus_message_iter_append_basic(&it[2], DBUS_TYPE_STRING, &str);
|
|
dbus_message_iter_open_container(&it[2], DBUS_TYPE_VARIANT, "q", &it[3]);
|
|
dbus_message_iter_append_basic(&it[3], DBUS_TYPE_UINT16, &chan);
|
|
dbus_message_iter_close_container(&it[2], &it[3]);
|
|
dbus_message_iter_close_container(&it[1], &it[2]);
|
|
|
|
/* HSP version 1.2 */
|
|
str = "Version";
|
|
version = 0x0102;
|
|
dbus_message_iter_open_container(&it[1], DBUS_TYPE_DICT_ENTRY, NULL, &it[2]);
|
|
dbus_message_iter_append_basic(&it[2], DBUS_TYPE_STRING, &str);
|
|
dbus_message_iter_open_container(&it[2], DBUS_TYPE_VARIANT, "q", &it[3]);
|
|
dbus_message_iter_append_basic(&it[3], DBUS_TYPE_UINT16, &version);
|
|
dbus_message_iter_close_container(&it[2], &it[3]);
|
|
dbus_message_iter_close_container(&it[1], &it[2]);
|
|
} else if (spa_streq(uuid, SPA_BT_UUID_HFP_AG)) {
|
|
str = "Features";
|
|
|
|
/* We announce wideband speech support anyway */
|
|
features = SPA_BT_HFP_SDP_AG_FEATURE_WIDEBAND_SPEECH;
|
|
dbus_message_iter_open_container(&it[1], DBUS_TYPE_DICT_ENTRY, NULL, &it[2]);
|
|
dbus_message_iter_append_basic(&it[2], DBUS_TYPE_STRING, &str);
|
|
dbus_message_iter_open_container(&it[2], DBUS_TYPE_VARIANT, "q", &it[3]);
|
|
dbus_message_iter_append_basic(&it[3], DBUS_TYPE_UINT16, &features);
|
|
dbus_message_iter_close_container(&it[2], &it[3]);
|
|
dbus_message_iter_close_container(&it[1], &it[2]);
|
|
|
|
/* HFP version 1.7 */
|
|
str = "Version";
|
|
version = 0x0107;
|
|
dbus_message_iter_open_container(&it[1], DBUS_TYPE_DICT_ENTRY, NULL, &it[2]);
|
|
dbus_message_iter_append_basic(&it[2], DBUS_TYPE_STRING, &str);
|
|
dbus_message_iter_open_container(&it[2], DBUS_TYPE_VARIANT, "q", &it[3]);
|
|
dbus_message_iter_append_basic(&it[3], DBUS_TYPE_UINT16, &version);
|
|
dbus_message_iter_close_container(&it[2], &it[3]);
|
|
dbus_message_iter_close_container(&it[1], &it[2]);
|
|
} else if (spa_streq(uuid, SPA_BT_UUID_HFP_HF)) {
|
|
str = "Features";
|
|
|
|
/* We announce wideband speech support anyway */
|
|
features = SPA_BT_HFP_SDP_HF_FEATURE_WIDEBAND_SPEECH;
|
|
dbus_message_iter_open_container(&it[1], DBUS_TYPE_DICT_ENTRY, NULL, &it[2]);
|
|
dbus_message_iter_append_basic(&it[2], DBUS_TYPE_STRING, &str);
|
|
dbus_message_iter_open_container(&it[2], DBUS_TYPE_VARIANT, "q", &it[3]);
|
|
dbus_message_iter_append_basic(&it[3], DBUS_TYPE_UINT16, &features);
|
|
dbus_message_iter_close_container(&it[2], &it[3]);
|
|
dbus_message_iter_close_container(&it[1], &it[2]);
|
|
|
|
/* HFP version 1.7 */
|
|
str = "Version";
|
|
version = 0x0107;
|
|
dbus_message_iter_open_container(&it[1], DBUS_TYPE_DICT_ENTRY, NULL, &it[2]);
|
|
dbus_message_iter_append_basic(&it[2], DBUS_TYPE_STRING, &str);
|
|
dbus_message_iter_open_container(&it[2], DBUS_TYPE_VARIANT, "q", &it[3]);
|
|
dbus_message_iter_append_basic(&it[3], DBUS_TYPE_UINT16, &version);
|
|
dbus_message_iter_close_container(&it[2], &it[3]);
|
|
dbus_message_iter_close_container(&it[1], &it[2]);
|
|
}
|
|
dbus_message_iter_close_container(&it[0], &it[1]);
|
|
|
|
if (!send_with_reply(backend->conn, m, register_profile_reply, backend))
|
|
return -EIO;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void unregister_profile(struct impl *backend, const char *profile)
|
|
{
|
|
spa_autoptr(DBusMessage) m = NULL, r = NULL;
|
|
spa_auto(DBusError) err = DBUS_ERROR_INIT;
|
|
|
|
spa_log_debug(backend->log, "Unregistering Profile %s", profile);
|
|
|
|
m = dbus_message_new_method_call(BLUEZ_SERVICE, "/org/bluez",
|
|
BLUEZ_PROFILE_MANAGER_INTERFACE, "UnregisterProfile");
|
|
if (m == NULL)
|
|
return;
|
|
|
|
dbus_message_append_args(m, DBUS_TYPE_OBJECT_PATH, &profile, DBUS_TYPE_INVALID);
|
|
|
|
r = dbus_connection_send_with_reply_and_block(backend->conn, m, -1, &err);
|
|
if (r == NULL) {
|
|
spa_log_info(backend->log, "Unregistering Profile %s failed", profile);
|
|
return;
|
|
}
|
|
|
|
if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
|
|
spa_log_error(backend->log, "UnregisterProfile() returned error: %s", dbus_message_get_error_name(r));
|
|
return;
|
|
}
|
|
}
|
|
|
|
static int backend_native_register_profiles(void *data)
|
|
{
|
|
struct impl *backend = data;
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HSP_NATIVE
|
|
register_profile(backend, PROFILE_HSP_AG, SPA_BT_UUID_HSP_AG);
|
|
register_profile(backend, PROFILE_HSP_HS, SPA_BT_UUID_HSP_HS);
|
|
#endif
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
register_profile(backend, PROFILE_HFP_AG, SPA_BT_UUID_HFP_AG);
|
|
register_profile(backend, PROFILE_HFP_HF, SPA_BT_UUID_HFP_HF);
|
|
#endif
|
|
|
|
if (backend->enabled_profiles & SPA_BT_PROFILE_HEADSET_HEAD_UNIT)
|
|
sco_listen(backend);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void sco_close(struct impl *backend)
|
|
{
|
|
if (backend->sco.fd >= 0) {
|
|
if (backend->sco.loop)
|
|
spa_loop_remove_source(backend->sco.loop, &backend->sco);
|
|
shutdown(backend->sco.fd, SHUT_RDWR);
|
|
close (backend->sco.fd);
|
|
backend->sco.fd = -1;
|
|
}
|
|
}
|
|
|
|
static int backend_native_unregister_profiles(void *data)
|
|
{
|
|
struct impl *backend = data;
|
|
|
|
sco_close(backend);
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HSP_NATIVE
|
|
if (backend->enabled_profiles & SPA_BT_PROFILE_HSP_AG)
|
|
unregister_profile(backend, PROFILE_HSP_AG);
|
|
if (backend->enabled_profiles & SPA_BT_PROFILE_HSP_HS)
|
|
unregister_profile(backend, PROFILE_HSP_HS);
|
|
#endif
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
if (backend->enabled_profiles & SPA_BT_PROFILE_HFP_AG)
|
|
unregister_profile(backend, PROFILE_HFP_AG);
|
|
if (backend->enabled_profiles & SPA_BT_PROFILE_HFP_HF)
|
|
unregister_profile(backend, PROFILE_HFP_HF);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void send_ciev_for_each_rfcomm(struct impl *backend, int indicator, int value)
|
|
{
|
|
struct rfcomm *rfcomm;
|
|
|
|
spa_list_for_each(rfcomm, &backend->rfcomm_list, link) {
|
|
if (rfcomm->slc_configured &&
|
|
((indicator == CIND_CALL || indicator == CIND_CALLSETUP || indicator == CIND_CALLHELD) ||
|
|
(rfcomm->cind_call_notify && (rfcomm->cind_enabled_indicators & (1 << indicator)))))
|
|
rfcomm_send_reply(rfcomm, "+CIEV: %d,%d", indicator, value);
|
|
}
|
|
}
|
|
|
|
static void ring_timer_event(void *data, uint64_t expirations)
|
|
{
|
|
struct impl *backend = data;
|
|
const char *number;
|
|
unsigned int type;
|
|
struct timespec ts;
|
|
const uint64_t timeout = 1 * SPA_NSEC_PER_SEC;
|
|
struct rfcomm *rfcomm;
|
|
|
|
number = mm_get_incoming_call_number(backend->modemmanager);
|
|
if (number) {
|
|
if (spa_strstartswith(number, "+"))
|
|
type = INTERNATIONAL_NUMBER;
|
|
else
|
|
type = NATIONAL_NUMBER;
|
|
}
|
|
|
|
ts.tv_sec = timeout / SPA_NSEC_PER_SEC;
|
|
ts.tv_nsec = timeout % SPA_NSEC_PER_SEC;
|
|
spa_loop_utils_update_timer(backend->loop_utils, backend->ring_timer, &ts, NULL, false);
|
|
|
|
spa_list_for_each(rfcomm, &backend->rfcomm_list, link) {
|
|
if (rfcomm->slc_configured) {
|
|
rfcomm_send_reply(rfcomm, "RING");
|
|
if (rfcomm->clip_notify && number)
|
|
rfcomm_send_reply(rfcomm, "+CLIP: \"%s\",%u", number, type);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void set_call_active(bool active, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
|
|
if (backend->modem.active_call != active) {
|
|
backend->modem.active_call = active;
|
|
send_ciev_for_each_rfcomm(backend, CIND_CALL, active);
|
|
}
|
|
}
|
|
|
|
static void set_call_setup(enum call_setup value, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
enum call_setup old = backend->modem.call_setup;
|
|
|
|
if (backend->modem.call_setup != value) {
|
|
backend->modem.call_setup = value;
|
|
send_ciev_for_each_rfcomm(backend, CIND_CALLSETUP, value);
|
|
}
|
|
|
|
if (value == CIND_CALLSETUP_INCOMING) {
|
|
if (backend->ring_timer == NULL)
|
|
backend->ring_timer = spa_loop_utils_add_timer(backend->loop_utils, ring_timer_event, backend);
|
|
|
|
if (backend->ring_timer == NULL) {
|
|
spa_log_warn(backend->log, "Failed to create ring timer");
|
|
return;
|
|
}
|
|
|
|
ring_timer_event(backend, 0);
|
|
} else if (old == CIND_CALLSETUP_INCOMING) {
|
|
spa_loop_utils_update_timer(backend->loop_utils, backend->ring_timer, NULL, NULL, false);
|
|
}
|
|
}
|
|
|
|
static void set_battery_level(unsigned int level, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
|
|
if (backend->battery_level != level) {
|
|
backend->battery_level = level;
|
|
send_ciev_for_each_rfcomm(backend, CIND_BATTERY_LEVEL, level);
|
|
}
|
|
}
|
|
|
|
static void set_modem_operator_name(const char *name, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
|
|
if (backend->modem.operator_name) {
|
|
free(backend->modem.operator_name);
|
|
backend->modem.operator_name = NULL;
|
|
}
|
|
|
|
if (name)
|
|
backend->modem.operator_name = strdup(name);
|
|
}
|
|
|
|
static void set_modem_roaming(bool is_roaming, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
|
|
if (backend->modem.network_is_roaming != is_roaming) {
|
|
backend->modem.network_is_roaming = is_roaming;
|
|
send_ciev_for_each_rfcomm(backend, CIND_ROAM, is_roaming);
|
|
}
|
|
}
|
|
|
|
static void set_modem_own_number(const char *number, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
|
|
if (backend->modem.own_number) {
|
|
free(backend->modem.own_number);
|
|
backend->modem.own_number = NULL;
|
|
}
|
|
|
|
if (number)
|
|
backend->modem.own_number = strdup(number);
|
|
}
|
|
|
|
static void set_modem_service(bool available, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
|
|
if (backend->modem.network_has_service != available) {
|
|
backend->modem.network_has_service = available;
|
|
send_ciev_for_each_rfcomm(backend, CIND_SERVICE, available);
|
|
}
|
|
}
|
|
|
|
static void set_modem_signal_strength(unsigned int strength, void *user_data)
|
|
{
|
|
struct impl *backend = user_data;
|
|
|
|
if (backend->modem.signal_strength != strength) {
|
|
backend->modem.signal_strength = strength;
|
|
send_ciev_for_each_rfcomm(backend, CIND_SIGNAL, strength);
|
|
}
|
|
}
|
|
|
|
static void send_cmd_result(bool success, enum cmee_error error, void *user_data)
|
|
{
|
|
struct rfcomm *rfcomm = user_data;
|
|
|
|
if (success) {
|
|
rfcomm_send_reply(rfcomm, "OK");
|
|
return;
|
|
}
|
|
|
|
rfcomm_send_error(rfcomm, error);
|
|
}
|
|
|
|
static int backend_native_free(void *data)
|
|
{
|
|
struct impl *backend = data;
|
|
|
|
struct rfcomm *rfcomm;
|
|
|
|
sco_close(backend);
|
|
|
|
if (backend->modemmanager) {
|
|
mm_unregister(backend->modemmanager);
|
|
backend->modemmanager = NULL;
|
|
}
|
|
|
|
if (backend->upower) {
|
|
upower_unregister(backend->upower);
|
|
backend->upower = NULL;
|
|
}
|
|
|
|
if (backend->ring_timer)
|
|
spa_loop_utils_destroy_source(backend->loop_utils, backend->ring_timer);
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HSP_NATIVE
|
|
dbus_connection_unregister_object_path(backend->conn, PROFILE_HSP_AG);
|
|
dbus_connection_unregister_object_path(backend->conn, PROFILE_HSP_HS);
|
|
#endif
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
dbus_connection_unregister_object_path(backend->conn, PROFILE_HFP_AG);
|
|
dbus_connection_unregister_object_path(backend->conn, PROFILE_HFP_HF);
|
|
#endif
|
|
|
|
spa_list_consume(rfcomm, &backend->rfcomm_list, link)
|
|
rfcomm_free(rfcomm);
|
|
|
|
if (backend->modem.operator_name)
|
|
free(backend->modem.operator_name);
|
|
free(backend);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int parse_headset_roles(struct impl *backend, const struct spa_dict *info)
|
|
{
|
|
const char *str;
|
|
int profiles = SPA_BT_PROFILE_NULL;
|
|
|
|
if (!info)
|
|
goto fallback;
|
|
|
|
if ((str = spa_dict_lookup(info, PROP_KEY_ROLES)) == NULL &&
|
|
(str = spa_dict_lookup(info, PROP_KEY_HEADSET_ROLES)) == NULL)
|
|
goto fallback;
|
|
|
|
profiles = spa_bt_profiles_from_json_array(str);
|
|
if (profiles < 0)
|
|
goto fallback;
|
|
|
|
backend->enabled_profiles = profiles & SPA_BT_PROFILE_HEADSET_AUDIO;
|
|
return 0;
|
|
fallback:
|
|
backend->enabled_profiles = DEFAULT_ENABLED_PROFILES;
|
|
return 0;
|
|
}
|
|
|
|
static const struct spa_bt_backend_implementation backend_impl = {
|
|
SPA_VERSION_BT_BACKEND_IMPLEMENTATION,
|
|
.free = backend_native_free,
|
|
.register_profiles = backend_native_register_profiles,
|
|
.unregister_profiles = backend_native_unregister_profiles,
|
|
.ensure_codec = backend_native_ensure_codec,
|
|
.supports_codec = backend_native_supports_codec,
|
|
};
|
|
|
|
static const struct mm_ops mm_ops = {
|
|
.send_cmd_result = send_cmd_result,
|
|
.set_modem_service = set_modem_service,
|
|
.set_modem_signal_strength = set_modem_signal_strength,
|
|
.set_modem_operator_name = set_modem_operator_name,
|
|
.set_modem_own_number = set_modem_own_number,
|
|
.set_modem_roaming = set_modem_roaming,
|
|
.set_call_active = set_call_active,
|
|
.set_call_setup = set_call_setup,
|
|
};
|
|
|
|
struct spa_bt_backend *backend_native_new(struct spa_bt_monitor *monitor,
|
|
void *dbus_connection,
|
|
const struct spa_dict *info,
|
|
const struct spa_bt_quirks *quirks,
|
|
const struct spa_support *support,
|
|
uint32_t n_support)
|
|
{
|
|
struct impl *backend;
|
|
|
|
static const DBusObjectPathVTable vtable_profile = {
|
|
.message_function = profile_handler,
|
|
};
|
|
|
|
backend = calloc(1, sizeof(struct impl));
|
|
if (backend == NULL)
|
|
return NULL;
|
|
|
|
spa_bt_backend_set_implementation(&backend->this, &backend_impl, backend);
|
|
|
|
backend->this.name = "native";
|
|
backend->monitor = monitor;
|
|
backend->quirks = quirks;
|
|
backend->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log);
|
|
backend->dbus = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_DBus);
|
|
backend->main_loop = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Loop);
|
|
backend->main_system = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_System);
|
|
backend->loop_utils = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_LoopUtils);
|
|
backend->conn = dbus_connection;
|
|
backend->sco.fd = -1;
|
|
|
|
spa_log_topic_init(backend->log, &log_topic);
|
|
|
|
spa_list_init(&backend->rfcomm_list);
|
|
|
|
if (parse_headset_roles(backend, info) < 0)
|
|
goto fail;
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HSP_NATIVE
|
|
if (!dbus_connection_register_object_path(backend->conn,
|
|
PROFILE_HSP_AG,
|
|
&vtable_profile, backend)) {
|
|
goto fail;
|
|
}
|
|
|
|
if (!dbus_connection_register_object_path(backend->conn,
|
|
PROFILE_HSP_HS,
|
|
&vtable_profile, backend)) {
|
|
goto fail1;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
if (!dbus_connection_register_object_path(backend->conn,
|
|
PROFILE_HFP_AG,
|
|
&vtable_profile, backend)) {
|
|
goto fail2;
|
|
}
|
|
|
|
if (!dbus_connection_register_object_path(backend->conn,
|
|
PROFILE_HFP_HF,
|
|
&vtable_profile, backend)) {
|
|
goto fail3;
|
|
}
|
|
#endif
|
|
|
|
backend->modemmanager = mm_register(backend->log, backend->conn, info, &mm_ops, backend);
|
|
backend->upower = upower_register(backend->log, backend->conn, set_battery_level, backend);
|
|
|
|
return &backend->this;
|
|
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HFP_NATIVE
|
|
fail3:
|
|
dbus_connection_unregister_object_path(backend->conn, PROFILE_HFP_AG);
|
|
fail2:
|
|
#endif
|
|
#ifdef HAVE_BLUEZ_5_BACKEND_HSP_NATIVE
|
|
dbus_connection_unregister_object_path(backend->conn, PROFILE_HSP_HS);
|
|
fail1:
|
|
dbus_connection_unregister_object_path(backend->conn, PROFILE_HSP_AG);
|
|
#endif
|
|
fail:
|
|
free(backend);
|
|
return NULL;
|
|
}
|