device.c revision 2e5aed934840d99e8ece6def186a0956937db778 
1/*
2 *
3 *  BlueZ - Bluetooth protocol stack for Linux
4 *
5 *  Copyright (C) 2006-2007  Nokia Corporation
6 *  Copyright (C) 2004-2009  Marcel Holtmann <marcel@holtmann.org>
7 *
8 *
9 *  This program is free software; you can redistribute it and/or modify
10 *  it under the terms of the GNU General Public License as published by
11 *  the Free Software Foundation; either version 2 of the License, or
12 *  (at your option) any later version.
13 *
14 *  This program is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this program; if not, write to the Free Software
21 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
22 *
23 */
24
25#ifdef HAVE_CONFIG_H
26#include <config.h>
27#endif
28
29#include <stdio.h>
30#include <errno.h>
31#include <unistd.h>
32#include <sys/stat.h>
33#include <sys/param.h>
34#include <netinet/in.h>
35
36#include <bluetooth/bluetooth.h>
37#include <bluetooth/hci.h>
38#include <bluetooth/hci_lib.h>
39#include <bluetooth/sdp.h>
40#include <bluetooth/sdp_lib.h>
41
42#include <glib.h>
43#include <dbus/dbus.h>
44#include <gdbus.h>
45
46#include "logging.h"
47#include "textfile.h"
48#include "../src/adapter.h"
49#include "../src/device.h"
50
51#include "error.h"
52#include "ipc.h"
53#include "dbus-common.h"
54#include "device.h"
55#include "unix.h"
56#include "avdtp.h"
57#include "control.h"
58#include "headset.h"
59#include "gateway.h"
60#include "sink.h"
61
62#define AUDIO_INTERFACE "org.bluez.Audio"
63
64#define CONTROL_CONNECT_TIMEOUT 2
65#define AVDTP_CONNECT_TIMEOUT 1
66#define HEADSET_CONNECT_TIMEOUT 1
67
68typedef enum {
69	AUDIO_STATE_DISCONNECTED,
70	AUDIO_STATE_CONNECTING,
71	AUDIO_STATE_CONNECTED,
72} audio_state_t;
73
74struct dev_priv {
75	audio_state_t state;
76
77	headset_state_t hs_state;
78	sink_state_t sink_state;
79	avctp_state_t avctp_state;
80
81	DBusMessage *conn_req;
82	DBusMessage *dc_req;
83
84	guint control_timer;
85	guint avdtp_timer;
86	guint headset_timer;
87};
88
89static unsigned int sink_callback_id = 0;
90static unsigned int avctp_callback_id = 0;
91static unsigned int avdtp_callback_id = 0;
92static unsigned int headset_callback_id = 0;
93
94static void device_free(struct audio_device *dev)
95{
96	struct dev_priv *priv = dev->priv;
97
98	if (dev->conn)
99		dbus_connection_unref(dev->conn);
100
101	btd_device_unref(dev->btd_dev);
102
103	if (priv) {
104		if (priv->control_timer)
105			g_source_remove(priv->control_timer);
106		if (priv->avdtp_timer)
107			g_source_remove(priv->avdtp_timer);
108		if (priv->headset_timer)
109			g_source_remove(priv->headset_timer);
110		if (priv->dc_req)
111			dbus_message_unref(priv->dc_req);
112		if (priv->conn_req)
113			dbus_message_unref(priv->conn_req);
114		g_free(priv);
115	}
116
117	g_free(dev->path);
118	g_free(dev);
119}
120
121static const char *state2str(audio_state_t state)
122{
123	switch (state) {
124	case AUDIO_STATE_DISCONNECTED:
125		return "disconnected";
126	case AUDIO_STATE_CONNECTING:
127		return "connecting";
128	case AUDIO_STATE_CONNECTED:
129		return "connected";
130	default:
131		error("Invalid audio state %d", state);
132		return NULL;
133	}
134}
135
136static void device_set_state(struct audio_device *dev, audio_state_t new_state)
137{
138	struct dev_priv *priv = dev->priv;
139	const char *state_str;
140	DBusMessage *reply = NULL;
141
142	state_str = state2str(new_state);
143	if (!state_str)
144		return;
145
146	if (dev->priv->state == new_state) {
147		debug("state change attempted from %s to %s",
148							state_str, state_str);
149		return;
150	}
151
152	dev->priv->state = new_state;
153
154	if (priv->dc_req && new_state == AUDIO_STATE_DISCONNECTED) {
155		reply = dbus_message_new_method_return(priv->dc_req);
156		dbus_message_unref(priv->dc_req);
157		priv->dc_req = NULL;
158		g_dbus_send_message(dev->conn, reply);
159	}
160
161	if (priv->conn_req && new_state != AUDIO_STATE_CONNECTING) {
162		if (new_state == AUDIO_STATE_CONNECTED)
163			reply = dbus_message_new_method_return(priv->conn_req);
164		else
165			reply = g_dbus_create_error(priv->conn_req,
166							ERROR_INTERFACE
167							".ConnectFailed",
168							"Connecting failed");
169		dbus_message_unref(priv->conn_req);
170		priv->conn_req = NULL;
171		g_dbus_send_message(dev->conn, reply);
172	}
173
174	emit_property_changed(dev->conn, dev->path,
175				AUDIO_INTERFACE, "State",
176				DBUS_TYPE_STRING, &state_str);
177}
178
179static gboolean control_connect_timeout(gpointer user_data)
180{
181	struct audio_device *dev = user_data;
182
183	dev->priv->control_timer = 0;
184
185	if (dev->control)
186		avrcp_connect(dev);
187
188	return FALSE;
189}
190
191static gboolean device_set_control_timer(struct audio_device *dev)
192{
193	struct dev_priv *priv = dev->priv;
194
195	if (!dev->control)
196		return FALSE;
197
198	if (priv->control_timer)
199		return FALSE;
200
201	priv->control_timer = g_timeout_add_seconds(CONTROL_CONNECT_TIMEOUT,
202							control_connect_timeout,
203							dev);
204
205	return TRUE;
206}
207
208static void device_remove_control_timer(struct audio_device *dev)
209{
210	if (dev->priv->control_timer)
211		g_source_remove(dev->priv->control_timer);
212	dev->priv->control_timer = 0;
213}
214
215static gboolean avdtp_connect_timeout(gpointer user_data)
216{
217	struct audio_device *dev = user_data;
218
219	dev->priv->avdtp_timer = 0;
220
221	if (dev->sink) {
222		struct avdtp *session = avdtp_get(&dev->src, &dev->dst);
223
224		if (!session)
225			return FALSE;
226
227		sink_setup_stream(dev->sink, session);
228		avdtp_unref(session);
229	}
230
231	return FALSE;
232}
233
234static gboolean device_set_avdtp_timer(struct audio_device *dev)
235{
236	struct dev_priv *priv = dev->priv;
237
238	if (!dev->sink)
239		return FALSE;
240
241	if (priv->avdtp_timer)
242		return FALSE;
243
244	priv->avdtp_timer = g_timeout_add_seconds(AVDTP_CONNECT_TIMEOUT,
245							avdtp_connect_timeout,
246							dev);
247
248	return TRUE;
249}
250
251static void device_remove_avdtp_timer(struct audio_device *dev)
252{
253	if (dev->priv->avdtp_timer)
254		g_source_remove(dev->priv->avdtp_timer);
255	dev->priv->avdtp_timer = 0;
256}
257
258static gboolean headset_connect_timeout(gpointer user_data)
259{
260	struct audio_device *dev = user_data;
261	struct dev_priv *priv = dev->priv;
262
263	dev->priv->headset_timer = 0;
264
265	if (dev->headset == NULL)
266		return FALSE;
267
268	if (headset_config_stream(dev, FALSE, NULL, NULL) == 0) {
269		if (priv->state != AUDIO_STATE_CONNECTED &&
270				(priv->sink_state == SINK_STATE_CONNECTED ||
271				priv->sink_state == SINK_STATE_PLAYING))
272			device_set_state(dev, AUDIO_STATE_CONNECTED);
273	}
274
275	return FALSE;
276}
277
278static gboolean device_set_headset_timer(struct audio_device *dev)
279{
280	struct dev_priv *priv = dev->priv;
281
282	if (!dev->headset)
283		return FALSE;
284
285	if (priv->headset_timer)
286		return FALSE;
287
288	priv->headset_timer = g_timeout_add_seconds(HEADSET_CONNECT_TIMEOUT,
289						headset_connect_timeout, dev);
290
291	return TRUE;
292}
293
294static void device_remove_headset_timer(struct audio_device *dev)
295{
296	if (dev->priv->headset_timer)
297		g_source_remove(dev->priv->headset_timer);
298	dev->priv->headset_timer = 0;
299}
300
301static void device_avdtp_cb(struct audio_device *dev, struct avdtp *session,
302				avdtp_session_state_t old_state,
303				avdtp_session_state_t new_state,
304				void *user_data)
305{
306	if (!dev->sink || !dev->control)
307		return;
308
309	if (new_state == AVDTP_SESSION_STATE_CONNECTED) {
310		if (avdtp_stream_setup_active(session))
311			device_set_control_timer(dev);
312		else
313			avrcp_connect(dev);
314	}
315}
316
317static void device_sink_cb(struct audio_device *dev,
318				sink_state_t old_state,
319				sink_state_t new_state,
320				void *user_data)
321{
322	struct dev_priv *priv = dev->priv;
323
324	if (!dev->sink)
325		return;
326
327	priv->sink_state = new_state;
328
329	switch (new_state) {
330	case SINK_STATE_DISCONNECTED:
331		if (dev->control) {
332			device_remove_control_timer(dev);
333			avrcp_disconnect(dev);
334		}
335		if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
336			device_set_state(dev, AUDIO_STATE_DISCONNECTED);
337		else if (old_state == SINK_STATE_CONNECTING) {
338			switch (priv->hs_state) {
339			case HEADSET_STATE_CONNECTED:
340			case HEADSET_STATE_PLAY_IN_PROGRESS:
341			case HEADSET_STATE_PLAYING:
342				device_set_state(dev, AUDIO_STATE_CONNECTED);
343			default:
344				break;
345			}
346		}
347		break;
348	case SINK_STATE_CONNECTING:
349		device_remove_avdtp_timer(dev);
350		if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
351			device_set_state(dev, AUDIO_STATE_CONNECTING);
352		break;
353	case SINK_STATE_CONNECTED:
354		if (old_state == SINK_STATE_PLAYING)
355			break;
356		if (dev->auto_connect) {
357			if (!dev->headset)
358				device_set_state(dev, AUDIO_STATE_CONNECTED);
359			if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
360				device_set_headset_timer(dev);
361			else if (priv->hs_state == HEADSET_STATE_CONNECTED)
362				device_set_state(dev, AUDIO_STATE_CONNECTED);
363		} else if (priv->hs_state != HEADSET_STATE_CONNECTED)
364			device_set_state(dev, AUDIO_STATE_CONNECTED);
365		break;
366	case SINK_STATE_PLAYING:
367		break;
368	}
369}
370
371static void device_avctp_cb(struct audio_device *dev,
372				avctp_state_t old_state,
373				avctp_state_t new_state,
374				void *user_data)
375{
376	if (!dev->control)
377		return;
378
379	dev->priv->avctp_state = new_state;
380
381	switch (new_state) {
382	case AVCTP_STATE_DISCONNECTED:
383		break;
384	case AVCTP_STATE_CONNECTING:
385		device_remove_control_timer(dev);
386		break;
387	case AVCTP_STATE_CONNECTED:
388		break;
389	}
390}
391
392static void device_headset_cb(struct audio_device *dev,
393				headset_state_t old_state,
394				headset_state_t new_state,
395				void *user_data)
396{
397	struct dev_priv *priv = dev->priv;
398
399	if (!dev->headset)
400		return;
401
402	priv->hs_state = new_state;
403
404	switch (new_state) {
405	case HEADSET_STATE_DISCONNECTED:
406		device_remove_avdtp_timer(dev);
407		if (priv->sink_state != SINK_STATE_DISCONNECTED &&
408						dev->sink && priv->dc_req) {
409			sink_shutdown(dev->sink);
410			break;
411		}
412		if (priv->sink_state == SINK_STATE_DISCONNECTED)
413			device_set_state(dev, AUDIO_STATE_DISCONNECTED);
414		else if (old_state == HEADSET_STATE_CONNECT_IN_PROGRESS &&
415				(priv->sink_state == SINK_STATE_CONNECTED ||
416				priv->sink_state == SINK_STATE_PLAYING))
417			device_set_state(dev, AUDIO_STATE_CONNECTED);
418		break;
419	case HEADSET_STATE_CONNECT_IN_PROGRESS:
420		device_remove_headset_timer(dev);
421		if (priv->sink_state == SINK_STATE_DISCONNECTED)
422			device_set_state(dev, AUDIO_STATE_CONNECTING);
423		break;
424	case HEADSET_STATE_CONNECTED:
425		if (old_state == HEADSET_STATE_CONNECTED ||
426				old_state == HEADSET_STATE_PLAY_IN_PROGRESS ||
427				old_state == HEADSET_STATE_PLAYING)
428			break;
429		if (dev->auto_connect) {
430			if (!dev->sink)
431				device_set_state(dev, AUDIO_STATE_CONNECTED);
432			else if (priv->sink_state == SINK_STATE_DISCONNECTED)
433				device_set_avdtp_timer(dev);
434			else if (priv->sink_state == SINK_STATE_CONNECTED)
435				device_set_state(dev, AUDIO_STATE_CONNECTED);
436		} else if (priv->sink_state != SINK_STATE_CONNECTED)
437			device_set_state(dev, AUDIO_STATE_CONNECTED);
438		break;
439	case HEADSET_STATE_PLAY_IN_PROGRESS:
440		break;
441	case HEADSET_STATE_PLAYING:
442		break;
443	}
444}
445
446static DBusMessage *dev_connect(DBusConnection *conn, DBusMessage *msg,
447								void *data)
448{
449	struct audio_device *dev = data;
450	struct dev_priv *priv = dev->priv;
451
452	if (priv->state == AUDIO_STATE_CONNECTING)
453		return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress",
454						"Connect in Progress");
455	else if (priv->state == AUDIO_STATE_CONNECTED)
456		return g_dbus_create_error(msg, ERROR_INTERFACE
457						".AlreadyConnected",
458						"Already Connected");
459
460	dev->auto_connect = TRUE;
461
462	if (dev->headset)
463		headset_config_stream(dev, FALSE, NULL, NULL);
464
465	if (priv->state != AUDIO_STATE_CONNECTING && dev->sink) {
466		struct avdtp *session = avdtp_get(&dev->src, &dev->dst);
467
468		if (!session)
469			return g_dbus_create_error(msg, ERROR_INTERFACE
470					".Failed",
471					"Failed to get AVDTP session");
472
473		sink_setup_stream(dev->sink, session);
474		avdtp_unref(session);
475	}
476
477	/* The previous calls should cause a call to the state callback to
478	 * indicate AUDIO_STATE_CONNECTING */
479	if (priv->state != AUDIO_STATE_CONNECTING)
480		return g_dbus_create_error(msg, ERROR_INTERFACE
481				".ConnectFailed",
482				"Headset connect failed");
483
484	priv->conn_req = dbus_message_ref(msg);
485
486	return NULL;
487}
488
489static DBusMessage *dev_disconnect(DBusConnection *conn, DBusMessage *msg,
490								void *data)
491{
492	struct audio_device *dev = data;
493	struct dev_priv *priv = dev->priv;
494
495	if (priv->state == AUDIO_STATE_DISCONNECTED)
496		return g_dbus_create_error(msg, ERROR_INTERFACE ".NotConnected",
497						"Not connected");
498
499	if (priv->dc_req)
500		return dbus_message_new_method_return(msg);
501
502	priv->dc_req = dbus_message_ref(msg);
503
504	if (priv->hs_state != HEADSET_STATE_DISCONNECTED)
505		headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
506	else if (dev->sink && priv->sink_state != SINK_STATE_DISCONNECTED)
507		sink_shutdown(dev->sink);
508	else {
509		dbus_message_unref(priv->dc_req);
510		priv->dc_req = NULL;
511		return dbus_message_new_method_return(msg);
512	}
513
514	return NULL;
515}
516
517static DBusMessage *dev_get_properties(DBusConnection *conn, DBusMessage *msg,
518								void *data)
519{
520	struct audio_device *device = data;
521	DBusMessage *reply;
522	DBusMessageIter iter;
523	DBusMessageIter dict;
524	const char *state;
525
526	reply = dbus_message_new_method_return(msg);
527	if (!reply)
528		return NULL;
529
530	dbus_message_iter_init_append(reply, &iter);
531
532	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
533			DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
534			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
535			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
536
537	/* State */
538	state = state2str(device->priv->state);
539	if (state)
540		dict_append_entry(&dict, "State", DBUS_TYPE_STRING, &state);
541
542	dbus_message_iter_close_container(&iter, &dict);
543
544	return reply;
545}
546
547static GDBusMethodTable dev_methods[] = {
548	{ "Connect",		"",	"",	dev_connect,
549						G_DBUS_METHOD_FLAG_ASYNC },
550	{ "Disconnect",		"",	"",	dev_disconnect },
551	{ "GetProperties",	"",	"a{sv}",dev_get_properties },
552	{ NULL, NULL, NULL, NULL }
553};
554
555static GDBusSignalTable dev_signals[] = {
556	{ "PropertyChanged",		"sv"	},
557	{ NULL, NULL }
558};
559
560struct audio_device *audio_device_register(DBusConnection *conn,
561					struct btd_device *device,
562					const char *path, const bdaddr_t *src,
563					const bdaddr_t *dst)
564{
565	struct audio_device *dev;
566
567	if (!conn || !path)
568		return NULL;
569
570	dev = g_new0(struct audio_device, 1);
571
572	dev->btd_dev = btd_device_ref(device);
573	dev->path = g_strdup(path);
574	bacpy(&dev->dst, dst);
575	bacpy(&dev->src, src);
576	dev->conn = dbus_connection_ref(conn);
577	dev->priv = g_new0(struct dev_priv, 1);
578	dev->priv->state = AUDIO_STATE_DISCONNECTED;
579
580	if (!g_dbus_register_interface(dev->conn, dev->path,
581					AUDIO_INTERFACE,
582					dev_methods, dev_signals, NULL,
583					dev, NULL)) {
584		error("Unable to register %s on %s", AUDIO_INTERFACE,
585								dev->path);
586		device_free(dev);
587		return NULL;
588	}
589
590	debug("Registered interface %s on path %s", AUDIO_INTERFACE,
591								dev->path);
592
593	if (sink_callback_id == 0)
594		sink_callback_id = sink_add_state_cb(device_sink_cb, NULL);
595
596	if (avdtp_callback_id == 0)
597		avdtp_callback_id = avdtp_add_state_cb(device_avdtp_cb, NULL);
598	if (avctp_callback_id == 0)
599		avctp_callback_id = avctp_add_state_cb(device_avctp_cb, NULL);
600
601	if (headset_callback_id == 0)
602		headset_callback_id = headset_add_state_cb(device_headset_cb,
603									NULL);
604
605	return dev;
606}
607
608gboolean audio_device_is_connected(struct audio_device *dev,
609						const char *interface)
610{
611	if (!interface) {
612		if ((dev->sink || dev->source) &&
613			avdtp_is_connected(&dev->src, &dev->dst))
614			return TRUE;
615
616		if (dev->headset && headset_is_active(dev))
617			return TRUE;
618	}
619	else if (!strcmp(interface, AUDIO_SINK_INTERFACE) && dev->sink &&
620			avdtp_is_connected(&dev->src, &dev->dst))
621		return TRUE;
622	else if (!strcmp(interface, AUDIO_SOURCE_INTERFACE) && dev->source &&
623			avdtp_is_connected(&dev->src, &dev->dst))
624		return TRUE;
625	else if (!strcmp(interface, AUDIO_HEADSET_INTERFACE) && dev->headset &&
626			headset_is_active(dev))
627		return TRUE;
628	else if (!strcmp(interface, AUDIO_CONTROL_INTERFACE) && dev->control &&
629			control_is_active(dev))
630		return TRUE;
631	else if (!strcmp(interface, AUDIO_GATEWAY_INTERFACE) && dev->gateway &&
632			gateway_is_connected(dev))
633		return TRUE;
634
635	return FALSE;
636}
637
638void audio_device_unregister(struct audio_device *device)
639{
640	unix_device_removed(device);
641
642	if (device->headset)
643		headset_unregister(device);
644
645	if (device->sink)
646		sink_unregister(device);
647
648	if (device->control)
649		control_unregister(device);
650
651	g_dbus_unregister_interface(device->conn, device->path,
652						AUDIO_INTERFACE);
653
654	device_free(device);
655}
656