gboolean audio_device_is_active(struct audio_device *dev,
const char *interface)
{
if (!interface) {
if ((dev->sink || dev->source) &&
avdtp_is_connected(&dev->src, &dev->dst))
return TRUE;
if (dev->headset && headset_is_active(dev))
return TRUE;
} else if (!strcmp(interface, AUDIO_SINK_INTERFACE) && dev->sink &&
avdtp_is_connected(&dev->src, &dev->dst))
return TRUE;
else if (!strcmp(interface, AUDIO_SOURCE_INTERFACE) && dev->source &&
avdtp_is_connected(&dev->src, &dev->dst))
return TRUE;
else if (!strcmp(interface, AUDIO_HEADSET_INTERFACE) && dev->headset &&
headset_is_active(dev))
return TRUE;
else if (!strcmp(interface, AUDIO_CONTROL_INTERFACE) && dev->control &&
control_is_active(dev))
return TRUE;
else if (!strcmp(interface, AUDIO_GATEWAY_INTERFACE) && dev->gateway &&
gateway_is_connected(dev))
return TRUE;
return FALSE;
}
static void hf_io_cb(GIOChannel *chan, gpointer data)
{
bdaddr_t src, dst;
GError *err = NULL;
uint8_t ch;
const char *server_uuid, *remote_uuid;
struct audio_device *device;
int perr;
bt_io_get(chan, BT_IO_RFCOMM, &err,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_CHANNEL, &ch,
BT_IO_OPT_INVALID);
if (err) {
error("%s", err->message);
g_error_free(err);
return;
}
server_uuid = HFP_AG_UUID;
remote_uuid = HFP_HS_UUID;
device = manager_get_device(&src, &dst, TRUE);
if (!device)
goto drop;
if (!device->gateway) {
btd_device_add_uuid(device->btd_dev, remote_uuid);
if (!device->gateway)
goto drop;
}
if (gateway_is_connected(device)) {
DBG("Refusing new connection since one already exists");
goto drop;
}
if (gateway_connect_rfcomm(device, chan) < 0) {
error("Allocating new GIOChannel failed!");
goto drop;
}
perr = audio_device_request_authorization(device, server_uuid,
gateway_auth_cb, device);
if (perr < 0) {
DBG("Authorization denied!");
goto drop;
}
return;
drop:
g_io_channel_shutdown(chan, TRUE, NULL);
}
static void handle_uuid_cmd(char *pwbuf, int blen, int argc, char **argv)
{
extern int cloud_is_connected(void);
extern bool gateway_is_connected(void);
extern const char *gateway_get_uuid(void);
if (cloud_is_connected()) {
aos_cli_printf("uuid: %s\r\n", config_get_main_uuid());
#ifdef MESH_GATEWAY_SERVICE
} else if (gateway_is_connected()) {
aos_cli_printf("uuid: %s\r\n", gateway_get_uuid());
#endif
} else {
aos_cli_printf("alink is not connected\r\n");
}
}
static void sco_server_cb(GIOChannel *chan, GError *err, gpointer data)
{
int sk;
struct audio_device *device;
char addr[18];
bdaddr_t src, dst;
if (err) {
error("sco_server_cb: %s", err->message);
return;
}
bt_io_get(chan, BT_IO_SCO, &err,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_DEST, addr,
BT_IO_OPT_INVALID);
if (err) {
error("bt_io_get: %s", err->message);
goto drop;
}
device = manager_find_device(NULL, &src, &dst, AUDIO_HEADSET_INTERFACE,
FALSE);
if (!device)
device = manager_find_device(NULL, &src, &dst,
AUDIO_GATEWAY_INTERFACE,
FALSE);
if (!device)
goto drop;
if (device->headset) {
if (headset_get_state(device) < HEADSET_STATE_CONNECTED) {
DBG("Refusing SCO from non-connected headset");
goto drop;
}
if (!get_hfp_active(device)) {
error("Refusing non-HFP SCO connect attempt from %s",
addr);
goto drop;
}
if (headset_connect_sco(device, chan) < 0)
goto drop;
headset_set_state(device, HEADSET_STATE_PLAYING);
} else if (device->gateway) {
if (!gateway_is_connected(device)) {
DBG("Refusing SCO from non-connected AG");
goto drop;
}
if (gateway_connect_sco(device, chan) < 0)
goto drop;
} else
goto drop;
sk = g_io_channel_unix_get_fd(chan);
fcntl(sk, F_SETFL, 0);
DBG("Accepted SCO connection from %s", addr);
return;
drop:
g_io_channel_shutdown(chan, TRUE, NULL);
}
