1 /*
2 *
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2006-2010 Nokia Corporation
6 * Copyright (C) 2004-2010 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 <fcntl.h>
32 #include <unistd.h>
33 #include <stdlib.h>
34 #include <stdarg.h>
35 #include <signal.h>
36 #include <string.h>
37 #include <getopt.h>
38 #include <sys/ioctl.h>
39 #include <sys/socket.h>
40 #include <assert.h>
41
42 #include <bluetooth/bluetooth.h>
43 #include <bluetooth/sdp.h>
44 #include <bluetooth/sdp_lib.h>
45
46 #include <glib.h>
47 #include <dbus/dbus.h>
48 #include <gdbus.h>
49
50 #include "log.h"
51 #include "device.h"
52 #include "manager.h"
53 #include "error.h"
54 #include "telephony.h"
55 #include "headset.h"
56 #include "glib-helper.h"
57 #include "btio.h"
58 #include "dbus-common.h"
59 #include "../src/adapter.h"
60 #include "../src/device.h"
61
62 #define DC_TIMEOUT 3
63
64 #define RING_INTERVAL 3
65
66 #define BUF_SIZE 1024
67
68 #define HEADSET_GAIN_SPEAKER 'S'
69 #define HEADSET_GAIN_MICROPHONE 'M'
70
71 static struct {
72 gboolean telephony_ready; /* Telephony plugin initialized */
73 uint32_t features; /* HFP AG features */
74 const struct indicator *indicators; /* Available HFP indicators */
75 int er_mode; /* Event reporting mode */
76 int er_ind; /* Event reporting for indicators */
77 int rh; /* Response and Hold state */
78 char *number; /* Incoming phone number */
79 int number_type; /* Incoming number type */
80 guint ring_timer; /* For incoming call indication */
81 const char *chld; /* Response to AT+CHLD=? */
82 } ag = {
83 .telephony_ready = FALSE,
84 .features = 0,
85 .er_mode = 3,
86 .er_ind = 0,
87 .rh = BTRH_NOT_SUPPORTED,
88 .number = NULL,
89 .number_type = 0,
90 .ring_timer = 0,
91 };
92
93 static gboolean sco_hci = TRUE;
94 static gboolean fast_connectable = FALSE;
95
96 static GSList *active_devices = NULL;
97
98 static char *str_state[] = {
99 "HEADSET_STATE_DISCONNECTED",
100 "HEADSET_STATE_CONNECTING",
101 "HEADSET_STATE_CONNECTED",
102 "HEADSET_STATE_PLAY_IN_PROGRESS",
103 "HEADSET_STATE_PLAYING",
104 };
105
106 struct headset_state_callback {
107 headset_state_cb cb;
108 void *user_data;
109 unsigned int id;
110 };
111
112 struct headset_nrec_callback {
113 unsigned int id;
114 headset_nrec_cb cb;
115 void *user_data;
116 };
117
118 struct connect_cb {
119 unsigned int id;
120 headset_stream_cb_t cb;
121 void *cb_data;
122 };
123
124 struct pending_connect {
125 DBusMessage *msg;
126 DBusPendingCall *call;
127 GIOChannel *io;
128 int err;
129 headset_state_t target_state;
130 GSList *callbacks;
131 uint16_t svclass;
132 };
133
134 struct headset_slc {
135 char buf[BUF_SIZE];
136 int data_start;
137 int data_length;
138
139 gboolean cli_active;
140 gboolean cme_enabled;
141 gboolean cwa_enabled;
142 gboolean pending_ring;
143 gboolean inband_ring;
144 gboolean nrec;
145 gboolean nrec_req;
146
147 int sp_gain;
148 int mic_gain;
149
150 unsigned int hf_features;
151 };
152
153 struct headset {
154 uint32_t hsp_handle;
155 uint32_t hfp_handle;
156
157 int rfcomm_ch;
158
159 GIOChannel *rfcomm;
160 GIOChannel *tmp_rfcomm;
161 GIOChannel *sco;
162 guint sco_id;
163
164 gboolean auto_dc;
165
166 guint dc_timer;
167
168 gboolean hfp_active;
169 gboolean search_hfp;
170
171 headset_state_t state;
172 struct pending_connect *pending;
173
174 headset_lock_t lock;
175 struct headset_slc *slc;
176 GSList *nrec_cbs;
177 };
178
179 struct event {
180 const char *cmd;
181 int (*callback) (struct audio_device *device, const char *buf);
182 };
183
184 static GSList *headset_callbacks = NULL;
185
error_connect_failed(DBusConnection * conn,DBusMessage * msg,int err)186 static void error_connect_failed(DBusConnection *conn, DBusMessage *msg,
187 int err)
188 {
189 DBusMessage *reply = btd_error_failed(msg,
190 err < 0 ? strerror(-err) : "Connect failed");
191 g_dbus_send_message(conn, reply);
192 }
193
194 static int rfcomm_connect(struct audio_device *device, headset_stream_cb_t cb,
195 void *user_data, unsigned int *cb_id);
196 static int get_records(struct audio_device *device, headset_stream_cb_t cb,
197 void *user_data, unsigned int *cb_id);
198
print_ag_features(uint32_t features)199 static void print_ag_features(uint32_t features)
200 {
201 GString *gstr;
202 char *str;
203
204 if (features == 0) {
205 DBG("HFP AG features: (none)");
206 return;
207 }
208
209 gstr = g_string_new("HFP AG features: ");
210
211 if (features & AG_FEATURE_THREE_WAY_CALLING)
212 g_string_append(gstr, "\"Three-way calling\" ");
213 if (features & AG_FEATURE_EC_ANDOR_NR)
214 g_string_append(gstr, "\"EC and/or NR function\" ");
215 if (features & AG_FEATURE_VOICE_RECOGNITION)
216 g_string_append(gstr, "\"Voice recognition function\" ");
217 if (features & AG_FEATURE_INBAND_RINGTONE)
218 g_string_append(gstr, "\"In-band ring tone capability\" ");
219 if (features & AG_FEATURE_ATTACH_NUMBER_TO_VOICETAG)
220 g_string_append(gstr, "\"Attach a number to a voice tag\" ");
221 if (features & AG_FEATURE_REJECT_A_CALL)
222 g_string_append(gstr, "\"Ability to reject a call\" ");
223 if (features & AG_FEATURE_ENHANCED_CALL_STATUS)
224 g_string_append(gstr, "\"Enhanced call status\" ");
225 if (features & AG_FEATURE_ENHANCED_CALL_CONTROL)
226 g_string_append(gstr, "\"Enhanced call control\" ");
227 if (features & AG_FEATURE_EXTENDED_ERROR_RESULT_CODES)
228 g_string_append(gstr, "\"Extended Error Result Codes\" ");
229
230 str = g_string_free(gstr, FALSE);
231
232 DBG("%s", str);
233
234 g_free(str);
235 }
236
print_hf_features(uint32_t features)237 static void print_hf_features(uint32_t features)
238 {
239 GString *gstr;
240 char *str;
241
242 if (features == 0) {
243 DBG("HFP HF features: (none)");
244 return;
245 }
246
247 gstr = g_string_new("HFP HF features: ");
248
249 if (features & HF_FEATURE_EC_ANDOR_NR)
250 g_string_append(gstr, "\"EC and/or NR function\" ");
251 if (features & HF_FEATURE_CALL_WAITING_AND_3WAY)
252 g_string_append(gstr, "\"Call waiting and 3-way calling\" ");
253 if (features & HF_FEATURE_CLI_PRESENTATION)
254 g_string_append(gstr, "\"CLI presentation capability\" ");
255 if (features & HF_FEATURE_VOICE_RECOGNITION)
256 g_string_append(gstr, "\"Voice recognition activation\" ");
257 if (features & HF_FEATURE_REMOTE_VOLUME_CONTROL)
258 g_string_append(gstr, "\"Remote volume control\" ");
259 if (features & HF_FEATURE_ENHANCED_CALL_STATUS)
260 g_string_append(gstr, "\"Enhanced call status\" ");
261 if (features & HF_FEATURE_ENHANCED_CALL_CONTROL)
262 g_string_append(gstr, "\"Enhanced call control\" ");
263
264 str = g_string_free(gstr, FALSE);
265
266 DBG("%s", str);
267
268 g_free(str);
269 }
270
state2str(headset_state_t state)271 static const char *state2str(headset_state_t state)
272 {
273 switch (state) {
274 case HEADSET_STATE_DISCONNECTED:
275 return "disconnected";
276 case HEADSET_STATE_CONNECTING:
277 return "connecting";
278 case HEADSET_STATE_CONNECTED:
279 case HEADSET_STATE_PLAY_IN_PROGRESS:
280 return "connected";
281 case HEADSET_STATE_PLAYING:
282 return "playing";
283 }
284
285 return NULL;
286 }
287
headset_send_valist(struct headset * hs,char * format,va_list ap)288 static int headset_send_valist(struct headset *hs, char *format, va_list ap)
289 {
290 char rsp[BUF_SIZE];
291 ssize_t total_written, count;
292 int fd;
293
294 count = vsnprintf(rsp, sizeof(rsp), format, ap);
295
296 if (count < 0)
297 return -EINVAL;
298
299 if (!hs->rfcomm) {
300 error("headset_send: the headset is not connected");
301 return -EIO;
302 }
303
304 total_written = 0;
305 fd = g_io_channel_unix_get_fd(hs->rfcomm);
306
307 while (total_written < count) {
308 ssize_t written;
309
310 written = write(fd, rsp + total_written,
311 count - total_written);
312 if (written < 0)
313 return -errno;
314
315 total_written += written;
316 }
317
318 return 0;
319 }
320
321 static int __attribute__((format(printf, 2, 3)))
headset_send(struct headset * hs,char * format,...)322 headset_send(struct headset *hs, char *format, ...)
323 {
324 va_list ap;
325 int ret;
326
327 va_start(ap, format);
328 ret = headset_send_valist(hs, format, ap);
329 va_end(ap);
330
331 return ret;
332 }
333
supported_features(struct audio_device * device,const char * buf)334 static int supported_features(struct audio_device *device, const char *buf)
335 {
336 struct headset *hs = device->headset;
337 struct headset_slc *slc = hs->slc;
338 int err;
339
340 if (strlen(buf) < 9)
341 return -EINVAL;
342
343 slc->hf_features = strtoul(&buf[8], NULL, 10);
344
345 print_hf_features(slc->hf_features);
346
347 err = headset_send(hs, "\r\n+BRSF: %u\r\n", ag.features);
348 if (err < 0)
349 return err;
350
351 return headset_send(hs, "\r\nOK\r\n");
352 }
353
indicator_ranges(const struct indicator * indicators)354 static char *indicator_ranges(const struct indicator *indicators)
355 {
356 int i;
357 GString *gstr;
358
359 gstr = g_string_new("\r\n+CIND: ");
360
361 for (i = 0; indicators[i].desc != NULL; i++) {
362 if (i == 0)
363 g_string_append_printf(gstr, "(\"%s\",(%s))",
364 indicators[i].desc,
365 indicators[i].range);
366 else
367 g_string_append_printf(gstr, ",(\"%s\",(%s))",
368 indicators[i].desc,
369 indicators[i].range);
370 }
371
372 g_string_append(gstr, "\r\n");
373
374 return g_string_free(gstr, FALSE);
375 }
376
indicator_values(const struct indicator * indicators)377 static char *indicator_values(const struct indicator *indicators)
378 {
379 int i;
380 GString *gstr;
381
382 gstr = g_string_new("\r\n+CIND: ");
383
384 for (i = 0; indicators[i].desc != NULL; i++) {
385 if (i == 0)
386 g_string_append_printf(gstr, "%d", indicators[i].val);
387 else
388 g_string_append_printf(gstr, ",%d", indicators[i].val);
389 }
390
391 g_string_append(gstr, "\r\n");
392
393 return g_string_free(gstr, FALSE);
394 }
395
report_indicators(struct audio_device * device,const char * buf)396 static int report_indicators(struct audio_device *device, const char *buf)
397 {
398 struct headset *hs = device->headset;
399 int err;
400 char *str;
401
402 if (strlen(buf) < 8)
403 return -EINVAL;
404
405 if (ag.indicators == NULL) {
406 error("HFP AG indicators not initialized");
407 return headset_send(hs, "\r\nERROR\r\n");
408 }
409
410 if (buf[7] == '=')
411 str = indicator_ranges(ag.indicators);
412 else
413 str = indicator_values(ag.indicators);
414
415 err = headset_send(hs, "%s", str);
416
417 g_free(str);
418
419 if (err < 0)
420 return err;
421
422 return headset_send(hs, "\r\nOK\r\n");
423 }
424
pending_connect_complete(struct connect_cb * cb,struct audio_device * dev)425 static void pending_connect_complete(struct connect_cb *cb, struct audio_device *dev)
426 {
427 struct headset *hs = dev->headset;
428
429 if (hs->pending->err < 0)
430 cb->cb(NULL, cb->cb_data);
431 else
432 cb->cb(dev, cb->cb_data);
433 }
434
pending_connect_finalize(struct audio_device * dev)435 static void pending_connect_finalize(struct audio_device *dev)
436 {
437 struct headset *hs = dev->headset;
438 struct pending_connect *p = hs->pending;
439
440 if (p == NULL)
441 return;
442
443 if (p->svclass)
444 bt_cancel_discovery(&dev->src, &dev->dst);
445
446 g_slist_foreach(p->callbacks, (GFunc) pending_connect_complete, dev);
447
448 g_slist_foreach(p->callbacks, (GFunc) g_free, NULL);
449 g_slist_free(p->callbacks);
450
451 if (p->io) {
452 g_io_channel_shutdown(p->io, TRUE, NULL);
453 g_io_channel_unref(p->io);
454 }
455
456 if (p->msg)
457 dbus_message_unref(p->msg);
458
459 if (p->call) {
460 dbus_pending_call_cancel(p->call);
461 dbus_pending_call_unref(p->call);
462 }
463
464 g_free(p);
465
466 hs->pending = NULL;
467 }
468
pending_connect_init(struct headset * hs,headset_state_t target_state)469 static void pending_connect_init(struct headset *hs, headset_state_t target_state)
470 {
471 if (hs->pending) {
472 if (hs->pending->target_state < target_state)
473 hs->pending->target_state = target_state;
474 return;
475 }
476
477 hs->pending = g_new0(struct pending_connect, 1);
478 hs->pending->target_state = target_state;
479 }
480
connect_cb_new(struct headset * hs,headset_state_t target_state,headset_stream_cb_t func,void * user_data)481 static unsigned int connect_cb_new(struct headset *hs,
482 headset_state_t target_state,
483 headset_stream_cb_t func,
484 void *user_data)
485 {
486 struct connect_cb *cb;
487 static unsigned int free_cb_id = 1;
488
489 pending_connect_init(hs, target_state);
490
491 if (!func)
492 return 0;
493
494 cb = g_new(struct connect_cb, 1);
495
496 cb->cb = func;
497 cb->cb_data = user_data;
498 cb->id = free_cb_id++;
499
500 hs->pending->callbacks = g_slist_append(hs->pending->callbacks,
501 cb);
502
503 return cb->id;
504 }
505
506 static void __attribute__((format(printf, 3, 4)))
send_foreach_headset(GSList * devices,int (* cmp)(struct headset * hs),char * format,...)507 send_foreach_headset(GSList *devices,
508 int (*cmp) (struct headset *hs),
509 char *format, ...)
510 {
511 GSList *l;
512 va_list ap;
513
514 for (l = devices; l != NULL; l = l->next) {
515 struct audio_device *device = l->data;
516 struct headset *hs = device->headset;
517 int ret;
518
519 assert(hs != NULL);
520
521 if (cmp && cmp(hs) != 0)
522 continue;
523
524 va_start(ap, format);
525 ret = headset_send_valist(hs, format, ap);
526 if (ret < 0)
527 error("Failed to send to headset: %s (%d)",
528 strerror(-ret), -ret);
529 va_end(ap);
530 }
531 }
532
cli_cmp(struct headset * hs)533 static int cli_cmp(struct headset *hs)
534 {
535 struct headset_slc *slc = hs->slc;
536
537 if (!hs->hfp_active)
538 return -1;
539
540 if (slc->cli_active)
541 return 0;
542 else
543 return -1;
544 }
545
ring_timer_cb(gpointer data)546 static gboolean ring_timer_cb(gpointer data)
547 {
548 send_foreach_headset(active_devices, NULL, "\r\nRING\r\n");
549
550 if (ag.number)
551 send_foreach_headset(active_devices, cli_cmp,
552 "\r\n+CLIP: \"%s\",%d\r\n",
553 ag.number, ag.number_type);
554
555 return TRUE;
556 }
557
sco_connect_cb(GIOChannel * chan,GError * err,gpointer user_data)558 static void sco_connect_cb(GIOChannel *chan, GError *err, gpointer user_data)
559 {
560 int sk;
561 struct audio_device *dev = user_data;
562 struct headset *hs = dev->headset;
563 struct headset_slc *slc = hs->slc;
564 struct pending_connect *p = hs->pending;
565
566 if (err) {
567 error("%s", err->message);
568
569 if (p != NULL) {
570 p->err = -errno;
571 if (p->msg)
572 error_connect_failed(dev->conn, p->msg, p->err);
573 pending_connect_finalize(dev);
574 }
575
576 if (hs->rfcomm)
577 headset_set_state(dev, HEADSET_STATE_CONNECTED);
578 else
579 headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
580
581 return;
582 }
583
584 DBG("SCO socket opened for headset %s", dev->path);
585
586 sk = g_io_channel_unix_get_fd(chan);
587
588 DBG("SCO fd=%d", sk);
589
590 if (p) {
591 p->io = NULL;
592 if (p->msg) {
593 DBusMessage *reply;
594 reply = dbus_message_new_method_return(p->msg);
595 g_dbus_send_message(dev->conn, reply);
596 }
597
598 pending_connect_finalize(dev);
599 }
600
601 fcntl(sk, F_SETFL, 0);
602
603 headset_set_state(dev, HEADSET_STATE_PLAYING);
604
605 if (slc->pending_ring) {
606 ring_timer_cb(NULL);
607 ag.ring_timer = g_timeout_add_seconds(RING_INTERVAL,
608 ring_timer_cb,
609 NULL);
610 slc->pending_ring = FALSE;
611 }
612 }
613
sco_connect(struct audio_device * dev,headset_stream_cb_t cb,void * user_data,unsigned int * cb_id)614 static int sco_connect(struct audio_device *dev, headset_stream_cb_t cb,
615 void *user_data, unsigned int *cb_id)
616 {
617 struct headset *hs = dev->headset;
618 GError *err = NULL;
619 GIOChannel *io;
620
621 if (hs->state != HEADSET_STATE_CONNECTED)
622 return -EINVAL;
623
624 io = bt_io_connect(BT_IO_SCO, sco_connect_cb, dev, NULL, &err,
625 BT_IO_OPT_SOURCE_BDADDR, &dev->src,
626 BT_IO_OPT_DEST_BDADDR, &dev->dst,
627 BT_IO_OPT_INVALID);
628 if (!io) {
629 error("%s", err->message);
630 g_error_free(err);
631 return -EIO;
632 }
633
634 hs->sco = io;
635
636 headset_set_state(dev, HEADSET_STATE_PLAY_IN_PROGRESS);
637
638 pending_connect_init(hs, HEADSET_STATE_PLAYING);
639
640 if (cb) {
641 unsigned int id = connect_cb_new(hs, HEADSET_STATE_PLAYING,
642 cb, user_data);
643 if (cb_id)
644 *cb_id = id;
645 }
646
647 return 0;
648 }
649
hfp_cmp(struct headset * hs)650 static int hfp_cmp(struct headset *hs)
651 {
652 if (hs->hfp_active)
653 return 0;
654 else
655 return -1;
656 }
657
hfp_slc_complete(struct audio_device * dev)658 static void hfp_slc_complete(struct audio_device *dev)
659 {
660 struct headset *hs = dev->headset;
661 struct pending_connect *p = hs->pending;
662
663 DBG("HFP Service Level Connection established");
664
665 headset_set_state(dev, HEADSET_STATE_CONNECTED);
666
667 if (p == NULL)
668 return;
669
670 if (p->target_state == HEADSET_STATE_CONNECTED) {
671 if (p->msg) {
672 DBusMessage *reply = dbus_message_new_method_return(p->msg);
673 g_dbus_send_message(dev->conn, reply);
674 }
675 pending_connect_finalize(dev);
676 return;
677 }
678
679 p->err = sco_connect(dev, NULL, NULL, NULL);
680 if (p->err < 0) {
681 if (p->msg)
682 error_connect_failed(dev->conn, p->msg, p->err);
683 pending_connect_finalize(dev);
684 }
685 }
686
telephony_generic_rsp(struct audio_device * device,cme_error_t err)687 static int telephony_generic_rsp(struct audio_device *device, cme_error_t err)
688 {
689 struct headset *hs = device->headset;
690 struct headset_slc *slc = hs->slc;
691
692 if ((err != CME_ERROR_NONE) && slc->cme_enabled)
693 return headset_send(hs, "\r\n+CME ERROR: %d\r\n", err);
694
695 switch (err) {
696 case CME_ERROR_NONE:
697 return headset_send(hs, "\r\nOK\r\n");
698 case CME_ERROR_NO_NETWORK_SERVICE:
699 return headset_send(hs, "\r\nNO CARRIER\r\n");
700 default:
701 return headset_send(hs, "\r\nERROR\r\n");
702 }
703 }
704
telephony_event_reporting_rsp(void * telephony_device,cme_error_t err)705 int telephony_event_reporting_rsp(void *telephony_device, cme_error_t err)
706 {
707 struct audio_device *device = telephony_device;
708 struct headset *hs = device->headset;
709 struct headset_slc *slc = hs->slc;
710 int ret;
711
712 if (err != CME_ERROR_NONE)
713 return telephony_generic_rsp(telephony_device, err);
714
715 ret = headset_send(hs, "\r\nOK\r\n");
716 if (ret < 0)
717 return ret;
718
719 if (hs->state != HEADSET_STATE_CONNECTING)
720 return 0;
721
722 if (slc->hf_features & HF_FEATURE_CALL_WAITING_AND_3WAY &&
723 ag.features & AG_FEATURE_THREE_WAY_CALLING)
724 return 0;
725
726 hfp_slc_complete(device);
727
728 return 0;
729 }
730
event_reporting(struct audio_device * dev,const char * buf)731 static int event_reporting(struct audio_device *dev, const char *buf)
732 {
733 char **tokens; /* <mode>, <keyp>, <disp>, <ind>, <bfr> */
734
735 if (strlen(buf) < 13)
736 return -EINVAL;
737
738 tokens = g_strsplit(&buf[8], ",", 5);
739 if (g_strv_length(tokens) < 4) {
740 g_strfreev(tokens);
741 return -EINVAL;
742 }
743
744 ag.er_mode = atoi(tokens[0]);
745 ag.er_ind = atoi(tokens[3]);
746
747 g_strfreev(tokens);
748 tokens = NULL;
749
750 DBG("Event reporting (CMER): mode=%d, ind=%d",
751 ag.er_mode, ag.er_ind);
752
753 switch (ag.er_ind) {
754 case 0:
755 case 1:
756 telephony_event_reporting_req(dev, ag.er_ind);
757 break;
758 default:
759 return -EINVAL;
760 }
761
762 return 0;
763 }
764
call_hold(struct audio_device * dev,const char * buf)765 static int call_hold(struct audio_device *dev, const char *buf)
766 {
767 struct headset *hs = dev->headset;
768 int err;
769
770 if (strlen(buf) < 9)
771 return -EINVAL;
772
773 if (buf[8] != '?') {
774 telephony_call_hold_req(dev, &buf[8]);
775 return 0;
776 }
777
778 err = headset_send(hs, "\r\n+CHLD: (%s)\r\n", ag.chld);
779 if (err < 0)
780 return err;
781
782 err = headset_send(hs, "\r\nOK\r\n");
783 if (err < 0)
784 return err;
785
786 if (hs->state != HEADSET_STATE_CONNECTING)
787 return 0;
788
789 hfp_slc_complete(dev);
790
791 return 0;
792 }
793
telephony_key_press_rsp(void * telephony_device,cme_error_t err)794 int telephony_key_press_rsp(void *telephony_device, cme_error_t err)
795 {
796 return telephony_generic_rsp(telephony_device, err);
797 }
798
key_press(struct audio_device * device,const char * buf)799 static int key_press(struct audio_device *device, const char *buf)
800 {
801 if (strlen(buf) < 9)
802 return -EINVAL;
803
804 g_dbus_emit_signal(device->conn, device->path,
805 AUDIO_HEADSET_INTERFACE, "AnswerRequested",
806 DBUS_TYPE_INVALID);
807
808 if (ag.ring_timer) {
809 g_source_remove(ag.ring_timer);
810 ag.ring_timer = 0;
811 }
812
813 telephony_key_press_req(device, &buf[8]);
814
815 return 0;
816 }
817
telephony_answer_call_rsp(void * telephony_device,cme_error_t err)818 int telephony_answer_call_rsp(void *telephony_device, cme_error_t err)
819 {
820 return telephony_generic_rsp(telephony_device, err);
821 }
822
answer_call(struct audio_device * device,const char * buf)823 static int answer_call(struct audio_device *device, const char *buf)
824 {
825 if (ag.ring_timer) {
826 g_source_remove(ag.ring_timer);
827 ag.ring_timer = 0;
828 }
829
830 if (ag.number) {
831 g_free(ag.number);
832 ag.number = NULL;
833 }
834
835 telephony_answer_call_req(device);
836
837 return 0;
838 }
839
telephony_terminate_call_rsp(void * telephony_device,cme_error_t err)840 int telephony_terminate_call_rsp(void *telephony_device,
841 cme_error_t err)
842 {
843 struct audio_device *device = telephony_device;
844 struct headset *hs = device->headset;
845
846 if (err != CME_ERROR_NONE)
847 return telephony_generic_rsp(telephony_device, err);
848
849 g_dbus_emit_signal(device->conn, device->path,
850 AUDIO_HEADSET_INTERFACE, "CallTerminated",
851 DBUS_TYPE_INVALID);
852
853 return headset_send(hs, "\r\nOK\r\n");
854 }
855
terminate_call(struct audio_device * device,const char * buf)856 static int terminate_call(struct audio_device *device, const char *buf)
857 {
858 if (ag.number) {
859 g_free(ag.number);
860 ag.number = NULL;
861 }
862
863 if (ag.ring_timer) {
864 g_source_remove(ag.ring_timer);
865 ag.ring_timer = 0;
866 }
867
868 telephony_terminate_call_req(device);
869
870 return 0;
871 }
872
cli_notification(struct audio_device * device,const char * buf)873 static int cli_notification(struct audio_device *device, const char *buf)
874 {
875 struct headset *hs = device->headset;
876 struct headset_slc *slc = hs->slc;
877
878 if (strlen(buf) < 9)
879 return -EINVAL;
880
881 slc->cli_active = buf[8] == '1' ? TRUE : FALSE;
882
883 return headset_send(hs, "\r\nOK\r\n");
884 }
885
telephony_response_and_hold_rsp(void * telephony_device,cme_error_t err)886 int telephony_response_and_hold_rsp(void *telephony_device, cme_error_t err)
887 {
888 return telephony_generic_rsp(telephony_device, err);
889 }
890
response_and_hold(struct audio_device * device,const char * buf)891 static int response_and_hold(struct audio_device *device, const char *buf)
892 {
893 struct headset *hs = device->headset;
894
895 if (strlen(buf) < 8)
896 return -EINVAL;
897
898 if (ag.rh == BTRH_NOT_SUPPORTED)
899 return telephony_generic_rsp(device, CME_ERROR_NOT_SUPPORTED);
900
901 if (buf[7] == '=') {
902 telephony_response_and_hold_req(device, atoi(&buf[8]) < 0);
903 return 0;
904 }
905
906 if (ag.rh >= 0)
907 headset_send(hs, "\r\n+BTRH: %d\r\n", ag.rh);
908
909 return headset_send(hs, "\r\nOK\r\n");
910 }
911
telephony_last_dialed_number_rsp(void * telephony_device,cme_error_t err)912 int telephony_last_dialed_number_rsp(void *telephony_device, cme_error_t err)
913 {
914 return telephony_generic_rsp(telephony_device, err);
915 }
916
last_dialed_number(struct audio_device * device,const char * buf)917 static int last_dialed_number(struct audio_device *device, const char *buf)
918 {
919 telephony_last_dialed_number_req(device);
920
921 return 0;
922 }
923
telephony_dial_number_rsp(void * telephony_device,cme_error_t err)924 int telephony_dial_number_rsp(void *telephony_device, cme_error_t err)
925 {
926 return telephony_generic_rsp(telephony_device, err);
927 }
928
dial_number(struct audio_device * device,const char * buf)929 static int dial_number(struct audio_device *device, const char *buf)
930 {
931 char number[BUF_SIZE];
932 size_t buf_len;
933
934 buf_len = strlen(buf);
935
936 if (buf[buf_len - 1] != ';') {
937 DBG("Rejecting non-voice call dial request");
938 return -EINVAL;
939 }
940
941 memset(number, 0, sizeof(number));
942 strncpy(number, &buf[3], buf_len - 4);
943
944 telephony_dial_number_req(device, number);
945
946 return 0;
947 }
948
headset_set_gain(struct audio_device * device,uint16_t gain,char type)949 static int headset_set_gain(struct audio_device *device, uint16_t gain, char type)
950 {
951 struct headset *hs = device->headset;
952 struct headset_slc *slc = hs->slc;
953 const char *name, *property;
954
955 if (gain > 15) {
956 error("Invalid gain value: %u", gain);
957 return -EINVAL;
958 }
959
960 switch (type) {
961 case HEADSET_GAIN_SPEAKER:
962 if (slc->sp_gain == gain) {
963 DBG("Ignoring no-change in speaker gain");
964 return -EALREADY;
965 }
966 name = "SpeakerGainChanged";
967 property = "SpeakerGain";
968 slc->sp_gain = gain;
969 break;
970 case HEADSET_GAIN_MICROPHONE:
971 if (slc->mic_gain == gain) {
972 DBG("Ignoring no-change in microphone gain");
973 return -EALREADY;
974 }
975 name = "MicrophoneGainChanged";
976 property = "MicrophoneGain";
977 slc->mic_gain = gain;
978 break;
979 default:
980 error("Unknown gain setting");
981 return -EINVAL;
982 }
983
984 g_dbus_emit_signal(device->conn, device->path,
985 AUDIO_HEADSET_INTERFACE, name,
986 DBUS_TYPE_UINT16, &gain,
987 DBUS_TYPE_INVALID);
988
989 emit_property_changed(device->conn, device->path,
990 AUDIO_HEADSET_INTERFACE, property,
991 DBUS_TYPE_UINT16, &gain);
992
993 return 0;
994 }
995
signal_gain_setting(struct audio_device * device,const char * buf)996 static int signal_gain_setting(struct audio_device *device, const char *buf)
997 {
998 struct headset *hs = device->headset;
999 dbus_uint16_t gain;
1000 int err;
1001
1002 if (strlen(buf) < 8) {
1003 error("Too short string for Gain setting");
1004 return -EINVAL;
1005 }
1006
1007 gain = (dbus_uint16_t) strtol(&buf[7], NULL, 10);
1008
1009 err = headset_set_gain(device, gain, buf[5]);
1010 if (err < 0 && err != -EALREADY)
1011 return err;
1012
1013 return headset_send(hs, "\r\nOK\r\n");
1014 }
1015
telephony_transmit_dtmf_rsp(void * telephony_device,cme_error_t err)1016 int telephony_transmit_dtmf_rsp(void *telephony_device, cme_error_t err)
1017 {
1018 return telephony_generic_rsp(telephony_device, err);
1019 }
1020
dtmf_tone(struct audio_device * device,const char * buf)1021 static int dtmf_tone(struct audio_device *device, const char *buf)
1022 {
1023 char tone;
1024
1025 if (strlen(buf) < 8) {
1026 error("Too short string for DTMF tone");
1027 return -EINVAL;
1028 }
1029
1030 tone = buf[7];
1031 if (tone >= '#' && tone <= 'D')
1032 telephony_transmit_dtmf_req(device, tone);
1033 else
1034 return -EINVAL;
1035
1036 return 0;
1037 }
1038
telephony_subscriber_number_rsp(void * telephony_device,cme_error_t err)1039 int telephony_subscriber_number_rsp(void *telephony_device, cme_error_t err)
1040 {
1041 return telephony_generic_rsp(telephony_device, err);
1042 }
1043
subscriber_number(struct audio_device * device,const char * buf)1044 static int subscriber_number(struct audio_device *device, const char *buf)
1045 {
1046 telephony_subscriber_number_req(device);
1047
1048 return 0;
1049 }
1050
telephony_list_current_calls_rsp(void * telephony_device,cme_error_t err)1051 int telephony_list_current_calls_rsp(void *telephony_device, cme_error_t err)
1052 {
1053 return telephony_generic_rsp(telephony_device, err);
1054 }
1055
list_current_calls(struct audio_device * device,const char * buf)1056 static int list_current_calls(struct audio_device *device, const char *buf)
1057 {
1058 telephony_list_current_calls_req(device);
1059
1060 return 0;
1061 }
1062
extended_errors(struct audio_device * device,const char * buf)1063 static int extended_errors(struct audio_device *device, const char *buf)
1064 {
1065 struct headset *hs = device->headset;
1066 struct headset_slc *slc = hs->slc;
1067
1068 if (strlen(buf) < 9)
1069 return -EINVAL;
1070
1071 if (buf[8] == '1') {
1072 slc->cme_enabled = TRUE;
1073 DBG("CME errors enabled for headset %p", hs);
1074 } else {
1075 slc->cme_enabled = FALSE;
1076 DBG("CME errors disabled for headset %p", hs);
1077 }
1078
1079 return headset_send(hs, "\r\nOK\r\n");
1080 }
1081
call_waiting_notify(struct audio_device * device,const char * buf)1082 static int call_waiting_notify(struct audio_device *device, const char *buf)
1083 {
1084 struct headset *hs = device->headset;
1085 struct headset_slc *slc = hs->slc;
1086
1087 if (strlen(buf) < 9)
1088 return -EINVAL;
1089
1090 if (buf[8] == '1') {
1091 slc->cwa_enabled = TRUE;
1092 DBG("Call waiting notification enabled for headset %p", hs);
1093 } else {
1094 slc->cwa_enabled = FALSE;
1095 DBG("Call waiting notification disabled for headset %p", hs);
1096 }
1097
1098 return headset_send(hs, "\r\nOK\r\n");
1099 }
1100
telephony_operator_selection_rsp(void * telephony_device,cme_error_t err)1101 int telephony_operator_selection_rsp(void *telephony_device, cme_error_t err)
1102 {
1103 return telephony_generic_rsp(telephony_device, err);
1104 }
1105
telephony_call_hold_rsp(void * telephony_device,cme_error_t err)1106 int telephony_call_hold_rsp(void *telephony_device, cme_error_t err)
1107 {
1108 return telephony_generic_rsp(telephony_device, err);
1109 }
1110
telephony_nr_and_ec_rsp(void * telephony_device,cme_error_t err)1111 int telephony_nr_and_ec_rsp(void *telephony_device, cme_error_t err)
1112 {
1113 struct audio_device *device = telephony_device;
1114 struct headset *hs = device->headset;
1115 struct headset_slc *slc = hs->slc;
1116
1117 if (err == CME_ERROR_NONE) {
1118 GSList *l;
1119
1120 for (l = hs->nrec_cbs; l; l = l->next) {
1121 struct headset_nrec_callback *nrec_cb = l->data;
1122
1123 nrec_cb->cb(device, slc->nrec_req, nrec_cb->user_data);
1124 }
1125
1126 slc->nrec = hs->slc->nrec_req;
1127 }
1128
1129 return telephony_generic_rsp(telephony_device, err);
1130 }
1131
telephony_voice_dial_rsp(void * telephony_device,cme_error_t err)1132 int telephony_voice_dial_rsp(void *telephony_device, cme_error_t err)
1133 {
1134 return telephony_generic_rsp(telephony_device, err);
1135 }
1136
telephony_operator_selection_ind(int mode,const char * oper)1137 int telephony_operator_selection_ind(int mode, const char *oper)
1138 {
1139 if (!active_devices)
1140 return -ENODEV;
1141
1142 send_foreach_headset(active_devices, hfp_cmp,
1143 "\r\n+COPS: %d,0,\"%s\"\r\n",
1144 mode, oper);
1145 return 0;
1146 }
1147
operator_selection(struct audio_device * device,const char * buf)1148 static int operator_selection(struct audio_device *device, const char *buf)
1149 {
1150 struct headset *hs = device->headset;
1151
1152 if (strlen(buf) < 8)
1153 return -EINVAL;
1154
1155 switch (buf[7]) {
1156 case '?':
1157 telephony_operator_selection_req(device);
1158 break;
1159 case '=':
1160 return headset_send(hs, "\r\nOK\r\n");
1161 default:
1162 return -EINVAL;
1163 }
1164
1165 return 0;
1166 }
1167
nr_and_ec(struct audio_device * device,const char * buf)1168 static int nr_and_ec(struct audio_device *device, const char *buf)
1169 {
1170 struct headset *hs = device->headset;
1171 struct headset_slc *slc = hs->slc;
1172
1173 if (strlen(buf) < 9)
1174 return -EINVAL;
1175
1176 if (buf[8] == '0')
1177 slc->nrec_req = FALSE;
1178 else
1179 slc->nrec_req = TRUE;
1180
1181 telephony_nr_and_ec_req(device, slc->nrec_req);
1182
1183 return 0;
1184 }
1185
voice_dial(struct audio_device * device,const char * buf)1186 static int voice_dial(struct audio_device *device, const char *buf)
1187 {
1188 gboolean enable;
1189
1190 if (strlen(buf) < 9)
1191 return -EINVAL;
1192
1193 if (buf[8] == '0')
1194 enable = FALSE;
1195 else
1196 enable = TRUE;
1197
1198 telephony_voice_dial_req(device, enable);
1199
1200 return 0;
1201 }
1202
apple_command(struct audio_device * device,const char * buf)1203 static int apple_command(struct audio_device *device, const char *buf)
1204 {
1205 DBG("Got Apple command: %s", buf);
1206
1207 return telephony_generic_rsp(device, CME_ERROR_NONE);
1208 }
1209
1210 static struct event event_callbacks[] = {
1211 { "ATA", answer_call },
1212 { "ATD", dial_number },
1213 { "AT+VG", signal_gain_setting },
1214 { "AT+BRSF", supported_features },
1215 { "AT+CIND", report_indicators },
1216 { "AT+CMER", event_reporting },
1217 { "AT+CHLD", call_hold },
1218 { "AT+CHUP", terminate_call },
1219 { "AT+CKPD", key_press },
1220 { "AT+CLIP", cli_notification },
1221 { "AT+BTRH", response_and_hold },
1222 { "AT+BLDN", last_dialed_number },
1223 { "AT+VTS", dtmf_tone },
1224 { "AT+CNUM", subscriber_number },
1225 { "AT+CLCC", list_current_calls },
1226 { "AT+CMEE", extended_errors },
1227 { "AT+CCWA", call_waiting_notify },
1228 { "AT+COPS", operator_selection },
1229 { "AT+NREC", nr_and_ec },
1230 { "AT+BVRA", voice_dial },
1231 { "AT+XAPL", apple_command },
1232 { "AT+IPHONEACCEV", apple_command },
1233 { 0 }
1234 };
1235
handle_event(struct audio_device * device,const char * buf)1236 static int handle_event(struct audio_device *device, const char *buf)
1237 {
1238 struct event *ev;
1239
1240 DBG("Received %s", buf);
1241
1242 for (ev = event_callbacks; ev->cmd; ev++) {
1243 if (!strncmp(buf, ev->cmd, strlen(ev->cmd)))
1244 return ev->callback(device, buf);
1245 }
1246
1247 return -EINVAL;
1248 }
1249
close_sco(struct audio_device * device)1250 static void close_sco(struct audio_device *device)
1251 {
1252 struct headset *hs = device->headset;
1253
1254 if (hs->sco) {
1255 int sock = g_io_channel_unix_get_fd(hs->sco);
1256 shutdown(sock, SHUT_RDWR);
1257 g_io_channel_shutdown(hs->sco, TRUE, NULL);
1258 g_io_channel_unref(hs->sco);
1259 hs->sco = NULL;
1260 }
1261
1262 if (hs->sco_id) {
1263 g_source_remove(hs->sco_id);
1264 hs->sco_id = 0;
1265 }
1266 }
1267
rfcomm_io_cb(GIOChannel * chan,GIOCondition cond,struct audio_device * device)1268 static gboolean rfcomm_io_cb(GIOChannel *chan, GIOCondition cond,
1269 struct audio_device *device)
1270 {
1271 struct headset *hs;
1272 struct headset_slc *slc;
1273 unsigned char buf[BUF_SIZE];
1274 ssize_t bytes_read;
1275 size_t free_space;
1276 int fd;
1277
1278 if (cond & G_IO_NVAL)
1279 return FALSE;
1280
1281 hs = device->headset;
1282 slc = hs->slc;
1283
1284 if (cond & (G_IO_ERR | G_IO_HUP)) {
1285 DBG("ERR or HUP on RFCOMM socket");
1286 goto failed;
1287 }
1288
1289 fd = g_io_channel_unix_get_fd(chan);
1290
1291 bytes_read = read(fd, buf, sizeof(buf) - 1);
1292 if (bytes_read < 0)
1293 return TRUE;
1294
1295 free_space = sizeof(slc->buf) - slc->data_start -
1296 slc->data_length - 1;
1297
1298 if (free_space < (size_t) bytes_read) {
1299 /* Very likely that the HS is sending us garbage so
1300 * just ignore the data and disconnect */
1301 error("Too much data to fit incomming buffer");
1302 goto failed;
1303 }
1304
1305 memcpy(&slc->buf[slc->data_start], buf, bytes_read);
1306 slc->data_length += bytes_read;
1307
1308 /* Make sure the data is null terminated so we can use string
1309 * functions */
1310 slc->buf[slc->data_start + slc->data_length] = '\0';
1311
1312 while (slc->data_length > 0) {
1313 char *cr;
1314 int err;
1315 off_t cmd_len;
1316
1317 cr = strchr(&slc->buf[slc->data_start], '\r');
1318 if (!cr)
1319 break;
1320
1321 cmd_len = 1 + (off_t) cr - (off_t) &slc->buf[slc->data_start];
1322 *cr = '\0';
1323
1324 if (cmd_len > 1)
1325 err = handle_event(device, &slc->buf[slc->data_start]);
1326 else
1327 /* Silently skip empty commands */
1328 err = 0;
1329
1330 if (err == -EINVAL) {
1331 error("Badly formated or unrecognized command: %s",
1332 &slc->buf[slc->data_start]);
1333 err = headset_send(hs, "\r\nERROR\r\n");
1334 if (err < 0)
1335 goto failed;
1336 } else if (err < 0)
1337 error("Error handling command %s: %s (%d)",
1338 &slc->buf[slc->data_start],
1339 strerror(-err), -err);
1340
1341 slc->data_start += cmd_len;
1342 slc->data_length -= cmd_len;
1343
1344 if (!slc->data_length)
1345 slc->data_start = 0;
1346 }
1347
1348 return TRUE;
1349
1350 failed:
1351 headset_set_state(device, HEADSET_STATE_DISCONNECTED);
1352
1353 return FALSE;
1354 }
1355
sco_cb(GIOChannel * chan,GIOCondition cond,struct audio_device * device)1356 static gboolean sco_cb(GIOChannel *chan, GIOCondition cond,
1357 struct audio_device *device)
1358 {
1359 if (cond & G_IO_NVAL)
1360 return FALSE;
1361
1362 error("Audio connection got disconnected");
1363
1364 pending_connect_finalize(device);
1365 headset_set_state(device, HEADSET_STATE_CONNECTED);
1366
1367 return FALSE;
1368 }
1369
headset_connect_cb(GIOChannel * chan,GError * err,gpointer user_data)1370 void headset_connect_cb(GIOChannel *chan, GError *err, gpointer user_data)
1371 {
1372 struct audio_device *dev = user_data;
1373 struct headset *hs = dev->headset;
1374 struct pending_connect *p = hs->pending;
1375 char hs_address[18];
1376
1377 if (err) {
1378 error("%s", err->message);
1379 goto failed;
1380 }
1381
1382 /* For HFP telephony isn't ready just disconnect */
1383 if (hs->hfp_active && !ag.telephony_ready) {
1384 error("Unable to accept HFP connection since the telephony "
1385 "subsystem isn't initialized");
1386 goto failed;
1387 }
1388
1389 hs->rfcomm = hs->tmp_rfcomm;
1390 hs->tmp_rfcomm = NULL;
1391
1392 ba2str(&dev->dst, hs_address);
1393
1394 if (p)
1395 p->io = NULL;
1396 else
1397 hs->auto_dc = FALSE;
1398
1399 g_io_add_watch(chan, G_IO_IN | G_IO_ERR | G_IO_HUP| G_IO_NVAL,
1400 (GIOFunc) rfcomm_io_cb, dev);
1401
1402 DBG("%s: Connected to %s", dev->path, hs_address);
1403
1404 hs->slc = g_new0(struct headset_slc, 1);
1405 hs->slc->sp_gain = 15;
1406 hs->slc->mic_gain = 15;
1407 hs->slc->nrec = TRUE;
1408
1409 /* In HFP mode wait for Service Level Connection */
1410 if (hs->hfp_active)
1411 return;
1412
1413 headset_set_state(dev, HEADSET_STATE_CONNECTED);
1414
1415 if (p && p->target_state == HEADSET_STATE_PLAYING) {
1416 p->err = sco_connect(dev, NULL, NULL, NULL);
1417 if (p->err < 0)
1418 goto failed;
1419 return;
1420 }
1421
1422 if (p && p->msg) {
1423 DBusMessage *reply = dbus_message_new_method_return(p->msg);
1424 g_dbus_send_message(dev->conn, reply);
1425 }
1426
1427 pending_connect_finalize(dev);
1428
1429 return;
1430
1431 failed:
1432 if (p && p->msg)
1433 error_connect_failed(dev->conn, p->msg, p->err);
1434 pending_connect_finalize(dev);
1435 if (hs->rfcomm)
1436 headset_set_state(dev, HEADSET_STATE_CONNECTED);
1437 else
1438 headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
1439 }
1440
headset_set_channel(struct headset * headset,const sdp_record_t * record,uint16_t svc)1441 static int headset_set_channel(struct headset *headset,
1442 const sdp_record_t *record, uint16_t svc)
1443 {
1444 int ch;
1445 sdp_list_t *protos;
1446
1447 if (sdp_get_access_protos(record, &protos) < 0) {
1448 error("Unable to get access protos from headset record");
1449 return -1;
1450 }
1451
1452 ch = sdp_get_proto_port(protos, RFCOMM_UUID);
1453
1454 sdp_list_foreach(protos, (sdp_list_func_t) sdp_list_free, NULL);
1455 sdp_list_free(protos, NULL);
1456
1457 if (ch <= 0) {
1458 error("Unable to get RFCOMM channel from Headset record");
1459 return -1;
1460 }
1461
1462 headset->rfcomm_ch = ch;
1463
1464 if (svc == HANDSFREE_SVCLASS_ID) {
1465 headset->hfp_handle = record->handle;
1466 DBG("Discovered Handsfree service on channel %d", ch);
1467 } else {
1468 headset->hsp_handle = record->handle;
1469 DBG("Discovered Headset service on channel %d", ch);
1470 }
1471
1472 return 0;
1473 }
1474
get_record_cb(sdp_list_t * recs,int err,gpointer user_data)1475 static void get_record_cb(sdp_list_t *recs, int err, gpointer user_data)
1476 {
1477 struct audio_device *dev = user_data;
1478 struct headset *hs = dev->headset;
1479 struct pending_connect *p = hs->pending;
1480 sdp_record_t *record = NULL;
1481 sdp_list_t *r;
1482 uuid_t uuid;
1483
1484 assert(hs->pending != NULL);
1485
1486 if (err < 0) {
1487 error("Unable to get service record: %s (%d)",
1488 strerror(-err), -err);
1489 p->err = -err;
1490 if (p->msg)
1491 error_connect_failed(dev->conn, p->msg, p->err);
1492 goto failed;
1493 }
1494
1495 if (!recs || !recs->data) {
1496 error("No records found");
1497 goto failed_not_supported;
1498 }
1499
1500 sdp_uuid16_create(&uuid, p->svclass);
1501
1502 for (r = recs; r != NULL; r = r->next) {
1503 sdp_list_t *classes;
1504 uuid_t class;
1505
1506 record = r->data;
1507
1508 if (sdp_get_service_classes(record, &classes) < 0) {
1509 error("Unable to get service classes from record");
1510 continue;
1511 }
1512
1513 memcpy(&class, classes->data, sizeof(uuid));
1514
1515 sdp_list_free(classes, free);
1516
1517
1518 if (sdp_uuid_cmp(&class, &uuid) == 0)
1519 break;
1520 }
1521
1522 if (r == NULL) {
1523 error("No record found with UUID 0x%04x", p->svclass);
1524 goto failed_not_supported;
1525 }
1526
1527 if (headset_set_channel(hs, record, p->svclass) < 0) {
1528 error("Unable to extract RFCOMM channel from service record");
1529 goto failed_not_supported;
1530 }
1531
1532 /* Set svclass to 0 so we can easily check that SDP is no-longer
1533 * going on (to know if bt_cancel_discovery needs to be called) */
1534 p->svclass = 0;
1535
1536 err = rfcomm_connect(dev, NULL, NULL, NULL);
1537 if (err < 0) {
1538 error("Unable to connect: %s (%d)", strerror(-err), -err);
1539 p->err = -err;
1540 error_connect_failed(dev->conn, p->msg, p->err);
1541 goto failed;
1542 }
1543
1544 return;
1545
1546 failed_not_supported:
1547 if (p->svclass == HANDSFREE_SVCLASS_ID &&
1548 get_records(dev, NULL, NULL, NULL) == 0)
1549 return;
1550 if (p->msg) {
1551 DBusMessage *reply = btd_error_not_supported(p->msg);
1552 g_dbus_send_message(dev->conn, reply);
1553 }
1554 failed:
1555 p->svclass = 0;
1556 pending_connect_finalize(dev);
1557 headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
1558 }
1559
get_records(struct audio_device * device,headset_stream_cb_t cb,void * user_data,unsigned int * cb_id)1560 static int get_records(struct audio_device *device, headset_stream_cb_t cb,
1561 void *user_data, unsigned int *cb_id)
1562 {
1563 struct headset *hs = device->headset;
1564 uint16_t svclass;
1565 uuid_t uuid;
1566 int err;
1567
1568 if (hs->pending && hs->pending->svclass == HANDSFREE_SVCLASS_ID)
1569 svclass = HEADSET_SVCLASS_ID;
1570 else
1571 svclass = hs->search_hfp ? HANDSFREE_SVCLASS_ID :
1572 HEADSET_SVCLASS_ID;
1573
1574 sdp_uuid16_create(&uuid, svclass);
1575
1576 err = bt_search_service(&device->src, &device->dst, &uuid,
1577 get_record_cb, device, NULL);
1578 if (err < 0)
1579 return err;
1580
1581 if (hs->pending) {
1582 hs->pending->svclass = svclass;
1583 return 0;
1584 }
1585
1586 headset_set_state(device, HEADSET_STATE_CONNECTING);
1587
1588 pending_connect_init(hs, HEADSET_STATE_CONNECTED);
1589
1590 hs->pending->svclass = svclass;
1591
1592 if (cb) {
1593 unsigned int id;
1594 id = connect_cb_new(hs, HEADSET_STATE_CONNECTED,
1595 cb, user_data);
1596 if (cb_id)
1597 *cb_id = id;
1598 }
1599
1600 return 0;
1601 }
1602
rfcomm_connect(struct audio_device * dev,headset_stream_cb_t cb,void * user_data,unsigned int * cb_id)1603 static int rfcomm_connect(struct audio_device *dev, headset_stream_cb_t cb,
1604 void *user_data, unsigned int *cb_id)
1605 {
1606 struct headset *hs = dev->headset;
1607 char address[18];
1608 GError *err = NULL;
1609
1610 if (!manager_allow_headset_connection(dev))
1611 return -ECONNREFUSED;
1612
1613 if (hs->rfcomm_ch < 0)
1614 return get_records(dev, cb, user_data, cb_id);
1615
1616 ba2str(&dev->dst, address);
1617
1618 DBG("%s: Connecting to %s channel %d", dev->path, address,
1619 hs->rfcomm_ch);
1620
1621 hs->tmp_rfcomm = bt_io_connect(BT_IO_RFCOMM, headset_connect_cb, dev,
1622 NULL, &err,
1623 BT_IO_OPT_SOURCE_BDADDR, &dev->src,
1624 BT_IO_OPT_DEST_BDADDR, &dev->dst,
1625 BT_IO_OPT_CHANNEL, hs->rfcomm_ch,
1626 BT_IO_OPT_INVALID);
1627
1628 hs->rfcomm_ch = -1;
1629
1630 if (!hs->tmp_rfcomm) {
1631 error("%s", err->message);
1632 g_error_free(err);
1633 return -EIO;
1634 }
1635
1636 hs->hfp_active = hs->hfp_handle != 0 ? TRUE : FALSE;
1637
1638 headset_set_state(dev, HEADSET_STATE_CONNECTING);
1639
1640 pending_connect_init(hs, HEADSET_STATE_CONNECTED);
1641
1642 if (cb) {
1643 unsigned int id = connect_cb_new(hs, HEADSET_STATE_CONNECTED,
1644 cb, user_data);
1645 if (cb_id)
1646 *cb_id = id;
1647 }
1648
1649 return 0;
1650 }
1651
hs_stop(DBusConnection * conn,DBusMessage * msg,void * data)1652 static DBusMessage *hs_stop(DBusConnection *conn, DBusMessage *msg,
1653 void *data)
1654 {
1655 struct audio_device *device = data;
1656 struct headset *hs = device->headset;
1657 DBusMessage *reply = NULL;
1658
1659 if (hs->state < HEADSET_STATE_PLAY_IN_PROGRESS)
1660 return btd_error_not_connected(msg);
1661
1662 reply = dbus_message_new_method_return(msg);
1663 if (!reply)
1664 return NULL;
1665
1666 headset_set_state(device, HEADSET_STATE_CONNECTED);
1667
1668 return reply;
1669 }
1670
hs_is_playing(DBusConnection * conn,DBusMessage * msg,void * data)1671 static DBusMessage *hs_is_playing(DBusConnection *conn, DBusMessage *msg,
1672 void *data)
1673 {
1674 struct audio_device *device = data;
1675 struct headset *hs = device->headset;
1676 DBusMessage *reply;
1677 dbus_bool_t playing;
1678
1679 reply = dbus_message_new_method_return(msg);
1680 if (!reply)
1681 return NULL;
1682
1683 playing = (hs->state == HEADSET_STATE_PLAYING);
1684
1685 dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &playing,
1686 DBUS_TYPE_INVALID);
1687
1688 return reply;
1689 }
1690
hs_disconnect(DBusConnection * conn,DBusMessage * msg,void * data)1691 static DBusMessage *hs_disconnect(DBusConnection *conn, DBusMessage *msg,
1692 void *data)
1693 {
1694 struct audio_device *device = data;
1695 struct headset *hs = device->headset;
1696 char hs_address[18];
1697
1698 if (hs->state == HEADSET_STATE_DISCONNECTED)
1699 return btd_error_not_connected(msg);
1700
1701 headset_shutdown(device);
1702 ba2str(&device->dst, hs_address);
1703 info("Disconnected from %s, %s", hs_address, device->path);
1704
1705 return dbus_message_new_method_return(msg);
1706
1707 }
1708
hs_is_connected(DBusConnection * conn,DBusMessage * msg,void * data)1709 static DBusMessage *hs_is_connected(DBusConnection *conn,
1710 DBusMessage *msg,
1711 void *data)
1712 {
1713 struct audio_device *device = data;
1714 DBusMessage *reply;
1715 dbus_bool_t connected;
1716
1717 reply = dbus_message_new_method_return(msg);
1718 if (!reply)
1719 return NULL;
1720
1721 connected = (device->headset->state >= HEADSET_STATE_CONNECTED);
1722
1723 dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connected,
1724 DBUS_TYPE_INVALID);
1725
1726 return reply;
1727 }
1728
hs_connect(DBusConnection * conn,DBusMessage * msg,void * data)1729 static DBusMessage *hs_connect(DBusConnection *conn, DBusMessage *msg,
1730 void *data)
1731 {
1732 struct audio_device *device = data;
1733 struct headset *hs = device->headset;
1734 int err;
1735
1736 if (hs->state == HEADSET_STATE_CONNECTING)
1737 return btd_error_in_progress(msg);
1738 else if (hs->state > HEADSET_STATE_CONNECTING)
1739 return btd_error_already_connected(msg);
1740
1741 if (hs->hfp_handle && !ag.telephony_ready)
1742 return btd_error_not_ready(msg);
1743
1744 device->auto_connect = FALSE;
1745
1746 err = rfcomm_connect(device, NULL, NULL, NULL);
1747 if (err < 0)
1748 return btd_error_failed(msg, strerror(-err));
1749
1750 hs->auto_dc = FALSE;
1751
1752 hs->pending->msg = dbus_message_ref(msg);
1753
1754 return NULL;
1755 }
1756
hs_ring(DBusConnection * conn,DBusMessage * msg,void * data)1757 static DBusMessage *hs_ring(DBusConnection *conn, DBusMessage *msg,
1758 void *data)
1759 {
1760 struct audio_device *device = data;
1761 struct headset *hs = device->headset;
1762 DBusMessage *reply = NULL;
1763 int err;
1764
1765 if (hs->state < HEADSET_STATE_CONNECTED)
1766 return btd_error_not_connected(msg);
1767
1768 reply = dbus_message_new_method_return(msg);
1769 if (!reply)
1770 return NULL;
1771
1772 if (ag.ring_timer) {
1773 DBG("IndicateCall received when already indicating");
1774 goto done;
1775 }
1776
1777 err = headset_send(hs, "\r\nRING\r\n");
1778 if (err < 0) {
1779 dbus_message_unref(reply);
1780 return btd_error_failed(msg, strerror(-err));
1781 }
1782
1783 ring_timer_cb(NULL);
1784 ag.ring_timer = g_timeout_add_seconds(RING_INTERVAL, ring_timer_cb,
1785 NULL);
1786
1787 done:
1788 return reply;
1789 }
1790
hs_cancel_call(DBusConnection * conn,DBusMessage * msg,void * data)1791 static DBusMessage *hs_cancel_call(DBusConnection *conn,
1792 DBusMessage *msg,
1793 void *data)
1794 {
1795 struct audio_device *device = data;
1796 struct headset *hs = device->headset;
1797 DBusMessage *reply = NULL;
1798
1799 if (hs->state < HEADSET_STATE_CONNECTED)
1800 return btd_error_not_connected(msg);
1801
1802 reply = dbus_message_new_method_return(msg);
1803 if (!reply)
1804 return NULL;
1805
1806 if (ag.ring_timer) {
1807 g_source_remove(ag.ring_timer);
1808 ag.ring_timer = 0;
1809 } else
1810 DBG("Got CancelCall method call but no call is active");
1811
1812 return reply;
1813 }
1814
hs_play(DBusConnection * conn,DBusMessage * msg,void * data)1815 static DBusMessage *hs_play(DBusConnection *conn, DBusMessage *msg,
1816 void *data)
1817 {
1818 struct audio_device *device = data;
1819 struct headset *hs = device->headset;
1820 int err;
1821
1822 if (sco_hci) {
1823 error("Refusing Headset.Play() because SCO HCI routing "
1824 "is enabled");
1825 return btd_error_not_available(msg);
1826 }
1827
1828 switch (hs->state) {
1829 case HEADSET_STATE_DISCONNECTED:
1830 case HEADSET_STATE_CONNECTING:
1831 return btd_error_not_connected(msg);
1832 case HEADSET_STATE_PLAY_IN_PROGRESS:
1833 if (hs->pending && hs->pending->msg == NULL) {
1834 hs->pending->msg = dbus_message_ref(msg);
1835 return NULL;
1836 }
1837 return btd_error_busy(msg);
1838 case HEADSET_STATE_PLAYING:
1839 return btd_error_already_connected(msg);
1840 case HEADSET_STATE_CONNECTED:
1841 default:
1842 break;
1843 }
1844
1845 err = sco_connect(device, NULL, NULL, NULL);
1846 if (err < 0)
1847 return btd_error_failed(msg, strerror(-err));
1848
1849 hs->pending->msg = dbus_message_ref(msg);
1850
1851 return NULL;
1852 }
1853
hs_get_speaker_gain(DBusConnection * conn,DBusMessage * msg,void * data)1854 static DBusMessage *hs_get_speaker_gain(DBusConnection *conn,
1855 DBusMessage *msg,
1856 void *data)
1857 {
1858 struct audio_device *device = data;
1859 struct headset *hs = device->headset;
1860 struct headset_slc *slc = hs->slc;
1861 DBusMessage *reply;
1862 dbus_uint16_t gain;
1863
1864 if (hs->state < HEADSET_STATE_CONNECTED)
1865 return btd_error_not_available(msg);
1866
1867 reply = dbus_message_new_method_return(msg);
1868 if (!reply)
1869 return NULL;
1870
1871 gain = (dbus_uint16_t) slc->sp_gain;
1872
1873 dbus_message_append_args(reply, DBUS_TYPE_UINT16, &gain,
1874 DBUS_TYPE_INVALID);
1875
1876 return reply;
1877 }
1878
hs_get_mic_gain(DBusConnection * conn,DBusMessage * msg,void * data)1879 static DBusMessage *hs_get_mic_gain(DBusConnection *conn,
1880 DBusMessage *msg,
1881 void *data)
1882 {
1883 struct audio_device *device = data;
1884 struct headset *hs = device->headset;
1885 struct headset_slc *slc = hs->slc;
1886 DBusMessage *reply;
1887 dbus_uint16_t gain;
1888
1889 if (hs->state < HEADSET_STATE_CONNECTED || slc == NULL)
1890 return btd_error_not_available(msg);
1891
1892 reply = dbus_message_new_method_return(msg);
1893 if (!reply)
1894 return NULL;
1895
1896 gain = (dbus_uint16_t) slc->mic_gain;
1897
1898 dbus_message_append_args(reply, DBUS_TYPE_UINT16, &gain,
1899 DBUS_TYPE_INVALID);
1900
1901 return reply;
1902 }
1903
hs_set_gain(DBusConnection * conn,DBusMessage * msg,void * data,uint16_t gain,char type)1904 static DBusMessage *hs_set_gain(DBusConnection *conn,
1905 DBusMessage *msg,
1906 void *data, uint16_t gain,
1907 char type)
1908 {
1909 struct audio_device *device = data;
1910 struct headset *hs = device->headset;
1911 DBusMessage *reply;
1912 int err;
1913
1914 if (hs->state < HEADSET_STATE_CONNECTED)
1915 return btd_error_not_connected(msg);
1916
1917 err = headset_set_gain(device, gain, type);
1918 if (err < 0)
1919 return btd_error_invalid_args(msg);
1920
1921 reply = dbus_message_new_method_return(msg);
1922 if (!reply)
1923 return NULL;
1924
1925 if (hs->state == HEADSET_STATE_PLAYING) {
1926 err = headset_send(hs, "\r\n+VG%c=%u\r\n", type, gain);
1927 if (err < 0) {
1928 dbus_message_unref(reply);
1929 return btd_error_failed(msg, strerror(-err));
1930 }
1931 }
1932
1933 return reply;
1934 }
1935
hs_set_speaker_gain(DBusConnection * conn,DBusMessage * msg,void * data)1936 static DBusMessage *hs_set_speaker_gain(DBusConnection *conn,
1937 DBusMessage *msg,
1938 void *data)
1939 {
1940 uint16_t gain;
1941
1942 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_UINT16, &gain,
1943 DBUS_TYPE_INVALID))
1944 return NULL;
1945
1946 return hs_set_gain(conn, msg, data, gain, HEADSET_GAIN_SPEAKER);
1947 }
1948
hs_set_mic_gain(DBusConnection * conn,DBusMessage * msg,void * data)1949 static DBusMessage *hs_set_mic_gain(DBusConnection *conn,
1950 DBusMessage *msg,
1951 void *data)
1952 {
1953 uint16_t gain;
1954
1955 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_UINT16, &gain,
1956 DBUS_TYPE_INVALID))
1957 return NULL;
1958
1959 return hs_set_gain(conn, msg, data, gain, HEADSET_GAIN_MICROPHONE);
1960 }
1961
hs_get_properties(DBusConnection * conn,DBusMessage * msg,void * data)1962 static DBusMessage *hs_get_properties(DBusConnection *conn,
1963 DBusMessage *msg, void *data)
1964 {
1965 struct audio_device *device = data;
1966 DBusMessage *reply;
1967 DBusMessageIter iter;
1968 DBusMessageIter dict;
1969 gboolean value;
1970 const char *state;
1971
1972 reply = dbus_message_new_method_return(msg);
1973 if (!reply)
1974 return NULL;
1975
1976 dbus_message_iter_init_append(reply, &iter);
1977
1978 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1979 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1980 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
1981 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
1982
1983
1984 /* Playing */
1985 value = (device->headset->state == HEADSET_STATE_PLAYING);
1986 dict_append_entry(&dict, "Playing", DBUS_TYPE_BOOLEAN, &value);
1987
1988 /* State */
1989 state = state2str(device->headset->state);
1990 if (state)
1991 dict_append_entry(&dict, "State", DBUS_TYPE_STRING, &state);
1992
1993 /* Connected */
1994 value = (device->headset->state >= HEADSET_STATE_CONNECTED);
1995 dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &value);
1996
1997 if (!value)
1998 goto done;
1999
2000 /* SpeakerGain */
2001 dict_append_entry(&dict, "SpeakerGain",
2002 DBUS_TYPE_UINT16,
2003 &device->headset->slc->sp_gain);
2004
2005 /* MicrophoneGain */
2006 dict_append_entry(&dict, "MicrophoneGain",
2007 DBUS_TYPE_UINT16,
2008 &device->headset->slc->mic_gain);
2009
2010 done:
2011 dbus_message_iter_close_container(&iter, &dict);
2012
2013 return reply;
2014 }
2015
hs_set_property(DBusConnection * conn,DBusMessage * msg,void * data)2016 static DBusMessage *hs_set_property(DBusConnection *conn,
2017 DBusMessage *msg, void *data)
2018 {
2019 const char *property;
2020 DBusMessageIter iter;
2021 DBusMessageIter sub;
2022 uint16_t gain;
2023
2024 if (!dbus_message_iter_init(msg, &iter))
2025 return btd_error_invalid_args(msg);
2026
2027 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
2028 return btd_error_invalid_args(msg);
2029
2030 dbus_message_iter_get_basic(&iter, &property);
2031 dbus_message_iter_next(&iter);
2032
2033 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
2034 return btd_error_invalid_args(msg);
2035 dbus_message_iter_recurse(&iter, &sub);
2036
2037 if (g_str_equal("SpeakerGain", property)) {
2038 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT16)
2039 return btd_error_invalid_args(msg);
2040
2041 dbus_message_iter_get_basic(&sub, &gain);
2042 return hs_set_gain(conn, msg, data, gain,
2043 HEADSET_GAIN_SPEAKER);
2044 } else if (g_str_equal("MicrophoneGain", property)) {
2045 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT16)
2046 return btd_error_invalid_args(msg);
2047
2048 dbus_message_iter_get_basic(&sub, &gain);
2049 return hs_set_gain(conn, msg, data, gain,
2050 HEADSET_GAIN_MICROPHONE);
2051 }
2052
2053 return btd_error_invalid_args(msg);
2054 }
2055 static GDBusMethodTable headset_methods[] = {
2056 { "Connect", "", "", hs_connect,
2057 G_DBUS_METHOD_FLAG_ASYNC },
2058 { "Disconnect", "", "", hs_disconnect },
2059 { "IsConnected", "", "b", hs_is_connected },
2060 { "IndicateCall", "", "", hs_ring },
2061 { "CancelCall", "", "", hs_cancel_call },
2062 { "Play", "", "", hs_play,
2063 G_DBUS_METHOD_FLAG_ASYNC },
2064 { "Stop", "", "", hs_stop },
2065 { "IsPlaying", "", "b", hs_is_playing,
2066 G_DBUS_METHOD_FLAG_DEPRECATED },
2067 { "GetSpeakerGain", "", "q", hs_get_speaker_gain,
2068 G_DBUS_METHOD_FLAG_DEPRECATED },
2069 { "GetMicrophoneGain", "", "q", hs_get_mic_gain,
2070 G_DBUS_METHOD_FLAG_DEPRECATED },
2071 { "SetSpeakerGain", "q", "", hs_set_speaker_gain,
2072 G_DBUS_METHOD_FLAG_DEPRECATED },
2073 { "SetMicrophoneGain", "q", "", hs_set_mic_gain,
2074 G_DBUS_METHOD_FLAG_DEPRECATED },
2075 { "GetProperties", "", "a{sv}",hs_get_properties },
2076 { "SetProperty", "sv", "", hs_set_property },
2077 { NULL, NULL, NULL, NULL }
2078 };
2079
2080 static GDBusSignalTable headset_signals[] = {
2081 { "Connected", "", G_DBUS_SIGNAL_FLAG_DEPRECATED },
2082 { "Disconnected", "", G_DBUS_SIGNAL_FLAG_DEPRECATED },
2083 { "AnswerRequested", "" },
2084 { "Stopped", "", G_DBUS_SIGNAL_FLAG_DEPRECATED },
2085 { "Playing", "", G_DBUS_SIGNAL_FLAG_DEPRECATED },
2086 { "SpeakerGainChanged", "q", G_DBUS_SIGNAL_FLAG_DEPRECATED },
2087 { "MicrophoneGainChanged", "q", G_DBUS_SIGNAL_FLAG_DEPRECATED },
2088 { "CallTerminated", "" },
2089 { "PropertyChanged", "sv" },
2090 { NULL, NULL }
2091 };
2092
headset_update(struct audio_device * dev,uint16_t svc,const char * uuidstr)2093 void headset_update(struct audio_device *dev, uint16_t svc,
2094 const char *uuidstr)
2095 {
2096 struct headset *headset = dev->headset;
2097 const sdp_record_t *record;
2098
2099 record = btd_device_get_record(dev->btd_dev, uuidstr);
2100 if (!record)
2101 return;
2102
2103 switch (svc) {
2104 case HANDSFREE_SVCLASS_ID:
2105 if (headset->hfp_handle &&
2106 (headset->hfp_handle != record->handle)) {
2107 error("More than one HFP record found on device");
2108 return;
2109 }
2110
2111 headset->hfp_handle = record->handle;
2112 break;
2113
2114 case HEADSET_SVCLASS_ID:
2115 if (headset->hsp_handle &&
2116 (headset->hsp_handle != record->handle)) {
2117 error("More than one HSP record found on device");
2118 return;
2119 }
2120
2121 headset->hsp_handle = record->handle;
2122
2123 /* Ignore this record if we already have access to HFP */
2124 if (headset->hfp_handle)
2125 return;
2126
2127 break;
2128
2129 default:
2130 DBG("Invalid record passed to headset_update");
2131 return;
2132 }
2133 }
2134
headset_close_rfcomm(struct audio_device * dev)2135 static int headset_close_rfcomm(struct audio_device *dev)
2136 {
2137 struct headset *hs = dev->headset;
2138 GIOChannel *rfcomm = hs->tmp_rfcomm ? hs->tmp_rfcomm : hs->rfcomm;
2139
2140 if (rfcomm) {
2141 g_io_channel_shutdown(rfcomm, TRUE, NULL);
2142 g_io_channel_unref(rfcomm);
2143 hs->tmp_rfcomm = NULL;
2144 hs->rfcomm = NULL;
2145 }
2146
2147 g_free(hs->slc);
2148 hs->slc = NULL;
2149
2150 return 0;
2151 }
2152
headset_free(struct audio_device * dev)2153 static void headset_free(struct audio_device *dev)
2154 {
2155 struct headset *hs = dev->headset;
2156
2157 if (hs->dc_timer) {
2158 g_source_remove(hs->dc_timer);
2159 hs->dc_timer = 0;
2160 }
2161
2162 close_sco(dev);
2163
2164 headset_close_rfcomm(dev);
2165
2166 g_slist_foreach(hs->nrec_cbs, (GFunc) g_free, NULL);
2167 g_slist_free(hs->nrec_cbs);
2168
2169 g_free(hs);
2170 dev->headset = NULL;
2171 }
2172
path_unregister(void * data)2173 static void path_unregister(void *data)
2174 {
2175 struct audio_device *dev = data;
2176 struct headset *hs = dev->headset;
2177
2178 if (hs->state > HEADSET_STATE_DISCONNECTED) {
2179 DBG("Headset unregistered while device was connected!");
2180 headset_shutdown(dev);
2181 }
2182
2183 DBG("Unregistered interface %s on path %s",
2184 AUDIO_HEADSET_INTERFACE, dev->path);
2185
2186 headset_free(dev);
2187 }
2188
headset_unregister(struct audio_device * dev)2189 void headset_unregister(struct audio_device *dev)
2190 {
2191 g_dbus_unregister_interface(dev->conn, dev->path,
2192 AUDIO_HEADSET_INTERFACE);
2193 }
2194
headset_init(struct audio_device * dev,uint16_t svc,const char * uuidstr)2195 struct headset *headset_init(struct audio_device *dev, uint16_t svc,
2196 const char *uuidstr)
2197 {
2198 struct headset *hs;
2199 const sdp_record_t *record;
2200
2201 hs = g_new0(struct headset, 1);
2202 hs->rfcomm_ch = -1;
2203 hs->search_hfp = server_is_enabled(&dev->src, HANDSFREE_SVCLASS_ID);
2204
2205 record = btd_device_get_record(dev->btd_dev, uuidstr);
2206 if (!record)
2207 goto register_iface;
2208
2209 switch (svc) {
2210 case HANDSFREE_SVCLASS_ID:
2211 hs->hfp_handle = record->handle;
2212 break;
2213
2214 case HEADSET_SVCLASS_ID:
2215 hs->hsp_handle = record->handle;
2216 break;
2217
2218 default:
2219 DBG("Invalid record passed to headset_init");
2220 g_free(hs);
2221 return NULL;
2222 }
2223
2224 register_iface:
2225 if (!g_dbus_register_interface(dev->conn, dev->path,
2226 AUDIO_HEADSET_INTERFACE,
2227 headset_methods, headset_signals, NULL,
2228 dev, path_unregister)) {
2229 g_free(hs);
2230 return NULL;
2231 }
2232
2233 DBG("Registered interface %s on path %s",
2234 AUDIO_HEADSET_INTERFACE, dev->path);
2235
2236 return hs;
2237 }
2238
headset_config_init(GKeyFile * config)2239 uint32_t headset_config_init(GKeyFile *config)
2240 {
2241 GError *err = NULL;
2242 char *str;
2243
2244 /* Use the default values if there is no config file */
2245 if (config == NULL)
2246 return ag.features;
2247
2248 str = g_key_file_get_string(config, "General", "SCORouting",
2249 &err);
2250 if (err) {
2251 DBG("audio.conf: %s", err->message);
2252 g_clear_error(&err);
2253 } else {
2254 if (strcmp(str, "PCM") == 0)
2255 sco_hci = FALSE;
2256 else if (strcmp(str, "HCI") == 0)
2257 sco_hci = TRUE;
2258 else
2259 error("Invalid Headset Routing value: %s", str);
2260 g_free(str);
2261 }
2262
2263 /* Init fast connectable option */
2264 str = g_key_file_get_string(config, "Headset", "FastConnectable",
2265 &err);
2266 if (err) {
2267 DBG("audio.conf: %s", err->message);
2268 g_clear_error(&err);
2269 } else {
2270 fast_connectable = strcmp(str, "true") == 0;
2271 if (fast_connectable)
2272 manager_set_fast_connectable(FALSE);
2273 g_free(str);
2274 }
2275
2276 return ag.features;
2277 }
2278
hs_dc_timeout(struct audio_device * dev)2279 static gboolean hs_dc_timeout(struct audio_device *dev)
2280 {
2281 headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
2282 return FALSE;
2283 }
2284
headset_cancel_stream(struct audio_device * dev,unsigned int id)2285 gboolean headset_cancel_stream(struct audio_device *dev, unsigned int id)
2286 {
2287 struct headset *hs = dev->headset;
2288 struct pending_connect *p = hs->pending;
2289 GSList *l;
2290 struct connect_cb *cb = NULL;
2291
2292 if (!p)
2293 return FALSE;
2294
2295 for (l = p->callbacks; l != NULL; l = l->next) {
2296 struct connect_cb *tmp = l->data;
2297
2298 if (tmp->id == id) {
2299 cb = tmp;
2300 break;
2301 }
2302 }
2303
2304 if (!cb)
2305 return FALSE;
2306
2307 p->callbacks = g_slist_remove(p->callbacks, cb);
2308 g_free(cb);
2309
2310 if (p->callbacks || p->msg)
2311 return TRUE;
2312
2313 if (hs->auto_dc) {
2314 if (hs->rfcomm)
2315 hs->dc_timer = g_timeout_add_seconds(DC_TIMEOUT,
2316 (GSourceFunc) hs_dc_timeout,
2317 dev);
2318 else
2319 headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
2320 }
2321
2322 return TRUE;
2323 }
2324
dummy_connect_complete(struct audio_device * dev)2325 static gboolean dummy_connect_complete(struct audio_device *dev)
2326 {
2327 pending_connect_finalize(dev);
2328 return FALSE;
2329 }
2330
headset_request_stream(struct audio_device * dev,headset_stream_cb_t cb,void * user_data)2331 unsigned int headset_request_stream(struct audio_device *dev,
2332 headset_stream_cb_t cb,
2333 void *user_data)
2334 {
2335 struct headset *hs = dev->headset;
2336 unsigned int id;
2337
2338 if (hs->state == HEADSET_STATE_PLAYING) {
2339 id = connect_cb_new(hs, HEADSET_STATE_PLAYING, cb, user_data);
2340 g_idle_add((GSourceFunc) dummy_connect_complete, dev);
2341 return id;
2342 }
2343
2344 if (hs->dc_timer) {
2345 g_source_remove(hs->dc_timer);
2346 hs->dc_timer = 0;
2347 }
2348
2349 if (hs->state == HEADSET_STATE_CONNECTING ||
2350 hs->state == HEADSET_STATE_PLAY_IN_PROGRESS)
2351 return connect_cb_new(hs, HEADSET_STATE_PLAYING, cb, user_data);
2352
2353 if (hs->rfcomm == NULL) {
2354 if (rfcomm_connect(dev, cb, user_data, &id) < 0)
2355 return 0;
2356 hs->auto_dc = TRUE;
2357 } else if (sco_connect(dev, cb, user_data, &id) < 0)
2358 return 0;
2359
2360 hs->pending->target_state = HEADSET_STATE_PLAYING;
2361
2362 return id;
2363 }
2364
headset_config_stream(struct audio_device * dev,gboolean auto_dc,headset_stream_cb_t cb,void * user_data)2365 unsigned int headset_config_stream(struct audio_device *dev,
2366 gboolean auto_dc,
2367 headset_stream_cb_t cb,
2368 void *user_data)
2369 {
2370 struct headset *hs = dev->headset;
2371 unsigned int id = 0;
2372
2373 if (hs->dc_timer) {
2374 g_source_remove(hs->dc_timer);
2375 hs->dc_timer = 0;
2376 }
2377
2378 if (hs->state == HEADSET_STATE_CONNECTING)
2379 return connect_cb_new(hs, HEADSET_STATE_CONNECTED, cb,
2380 user_data);
2381
2382 if (hs->rfcomm)
2383 goto done;
2384
2385 if (rfcomm_connect(dev, cb, user_data, &id) < 0)
2386 return 0;
2387
2388 hs->auto_dc = auto_dc;
2389 hs->pending->target_state = HEADSET_STATE_CONNECTED;
2390
2391 return id;
2392
2393 done:
2394 id = connect_cb_new(hs, HEADSET_STATE_CONNECTED, cb, user_data);
2395 g_idle_add((GSourceFunc) dummy_connect_complete, dev);
2396 return id;
2397 }
2398
headset_suspend_stream(struct audio_device * dev,headset_stream_cb_t cb,void * user_data)2399 unsigned int headset_suspend_stream(struct audio_device *dev,
2400 headset_stream_cb_t cb,
2401 void *user_data)
2402 {
2403 struct headset *hs = dev->headset;
2404 unsigned int id;
2405 int sock;
2406
2407 if (hs->state == HEADSET_STATE_DISCONNECTED ||
2408 hs->state == HEADSET_STATE_CONNECTING)
2409 return 0;
2410
2411 if (hs->dc_timer) {
2412 g_source_remove(hs->dc_timer);
2413 hs->dc_timer = 0;
2414 }
2415
2416 if (hs->sco) {
2417 sock = g_io_channel_unix_get_fd(hs->sco);
2418
2419 /* shutdown but leave the socket open and wait for hup */
2420 shutdown(sock, SHUT_RDWR);
2421 } else {
2422 headset_set_state(dev, HEADSET_STATE_CONNECTED);
2423
2424 g_idle_add((GSourceFunc) dummy_connect_complete, dev);
2425 }
2426
2427 id = connect_cb_new(hs, HEADSET_STATE_CONNECTED, cb, user_data);
2428
2429 return id;
2430 }
2431
get_hfp_active(struct audio_device * dev)2432 gboolean get_hfp_active(struct audio_device *dev)
2433 {
2434 struct headset *hs = dev->headset;
2435
2436 return hs->hfp_active;
2437 }
2438
set_hfp_active(struct audio_device * dev,gboolean active)2439 void set_hfp_active(struct audio_device *dev, gboolean active)
2440 {
2441 struct headset *hs = dev->headset;
2442
2443 hs->hfp_active = active;
2444 }
2445
headset_get_rfcomm(struct audio_device * dev)2446 GIOChannel *headset_get_rfcomm(struct audio_device *dev)
2447 {
2448 struct headset *hs = dev->headset;
2449
2450 return hs->tmp_rfcomm;
2451 }
2452
headset_connect_rfcomm(struct audio_device * dev,GIOChannel * io)2453 int headset_connect_rfcomm(struct audio_device *dev, GIOChannel *io)
2454 {
2455 struct headset *hs = dev->headset;
2456
2457 if (hs->tmp_rfcomm)
2458 return -EALREADY;
2459
2460 hs->tmp_rfcomm = g_io_channel_ref(io);
2461
2462 return 0;
2463 }
2464
headset_connect_sco(struct audio_device * dev,GIOChannel * io)2465 int headset_connect_sco(struct audio_device *dev, GIOChannel *io)
2466 {
2467 struct headset *hs = dev->headset;
2468 struct headset_slc *slc = hs->slc;
2469
2470 if (hs->sco)
2471 return -EISCONN;
2472
2473 hs->sco = g_io_channel_ref(io);
2474
2475 if (slc->pending_ring) {
2476 ring_timer_cb(NULL);
2477 ag.ring_timer = g_timeout_add_seconds(RING_INTERVAL,
2478 ring_timer_cb,
2479 NULL);
2480 slc->pending_ring = FALSE;
2481 }
2482
2483 return 0;
2484 }
2485
headset_set_state(struct audio_device * dev,headset_state_t state)2486 void headset_set_state(struct audio_device *dev, headset_state_t state)
2487 {
2488 struct headset *hs = dev->headset;
2489 struct headset_slc *slc = hs->slc;
2490 gboolean value;
2491 const char *state_str;
2492 headset_state_t old_state = hs->state;
2493 GSList *l;
2494
2495 if (old_state == state)
2496 return;
2497
2498 state_str = state2str(state);
2499
2500 switch (state) {
2501 case HEADSET_STATE_DISCONNECTED:
2502 value = FALSE;
2503 close_sco(dev);
2504 headset_close_rfcomm(dev);
2505 emit_property_changed(dev->conn, dev->path,
2506 AUDIO_HEADSET_INTERFACE, "State",
2507 DBUS_TYPE_STRING, &state_str);
2508 g_dbus_emit_signal(dev->conn, dev->path,
2509 AUDIO_HEADSET_INTERFACE,
2510 "Disconnected",
2511 DBUS_TYPE_INVALID);
2512 if (hs->state > HEADSET_STATE_CONNECTING) {
2513 emit_property_changed(dev->conn, dev->path,
2514 AUDIO_HEADSET_INTERFACE, "Connected",
2515 DBUS_TYPE_BOOLEAN, &value);
2516 telephony_device_disconnected(dev);
2517 }
2518 active_devices = g_slist_remove(active_devices, dev);
2519 break;
2520 case HEADSET_STATE_CONNECTING:
2521 emit_property_changed(dev->conn, dev->path,
2522 AUDIO_HEADSET_INTERFACE, "State",
2523 DBUS_TYPE_STRING, &state_str);
2524 break;
2525 case HEADSET_STATE_CONNECTED:
2526 close_sco(dev);
2527 if (hs->state != HEADSET_STATE_PLAY_IN_PROGRESS)
2528 emit_property_changed(dev->conn, dev->path,
2529 AUDIO_HEADSET_INTERFACE, "State",
2530 DBUS_TYPE_STRING, &state_str);
2531 if (hs->state < state) {
2532 if (ag.features & AG_FEATURE_INBAND_RINGTONE)
2533 slc->inband_ring = TRUE;
2534 else
2535 slc->inband_ring = FALSE;
2536 g_dbus_emit_signal(dev->conn, dev->path,
2537 AUDIO_HEADSET_INTERFACE,
2538 "Connected",
2539 DBUS_TYPE_INVALID);
2540 value = TRUE;
2541 emit_property_changed(dev->conn, dev->path,
2542 AUDIO_HEADSET_INTERFACE,
2543 "Connected",
2544 DBUS_TYPE_BOOLEAN, &value);
2545 active_devices = g_slist_append(active_devices, dev);
2546 telephony_device_connected(dev);
2547 } else if (hs->state == HEADSET_STATE_PLAYING) {
2548 value = FALSE;
2549 g_dbus_emit_signal(dev->conn, dev->path,
2550 AUDIO_HEADSET_INTERFACE,
2551 "Stopped",
2552 DBUS_TYPE_INVALID);
2553 emit_property_changed(dev->conn, dev->path,
2554 AUDIO_HEADSET_INTERFACE,
2555 "Playing",
2556 DBUS_TYPE_BOOLEAN, &value);
2557 }
2558 break;
2559 case HEADSET_STATE_PLAY_IN_PROGRESS:
2560 break;
2561 case HEADSET_STATE_PLAYING:
2562 value = TRUE;
2563 emit_property_changed(dev->conn, dev->path,
2564 AUDIO_HEADSET_INTERFACE, "State",
2565 DBUS_TYPE_STRING, &state_str);
2566
2567 /* Do not watch HUP since we need to know when the link is
2568 really disconnected */
2569 hs->sco_id = g_io_add_watch(hs->sco,
2570 G_IO_ERR | G_IO_NVAL,
2571 (GIOFunc) sco_cb, dev);
2572
2573 g_dbus_emit_signal(dev->conn, dev->path,
2574 AUDIO_HEADSET_INTERFACE, "Playing",
2575 DBUS_TYPE_INVALID);
2576 emit_property_changed(dev->conn, dev->path,
2577 AUDIO_HEADSET_INTERFACE, "Playing",
2578 DBUS_TYPE_BOOLEAN, &value);
2579
2580 if (slc->sp_gain >= 0)
2581 headset_send(hs, "\r\n+VGS=%u\r\n", slc->sp_gain);
2582 if (slc->mic_gain >= 0)
2583 headset_send(hs, "\r\n+VGM=%u\r\n", slc->mic_gain);
2584 break;
2585 }
2586
2587 hs->state = state;
2588
2589 DBG("State changed %s: %s -> %s", dev->path, str_state[old_state],
2590 str_state[state]);
2591
2592 for (l = headset_callbacks; l != NULL; l = l->next) {
2593 struct headset_state_callback *cb = l->data;
2594 cb->cb(dev, old_state, state, cb->user_data);
2595 }
2596 }
2597
headset_get_state(struct audio_device * dev)2598 headset_state_t headset_get_state(struct audio_device *dev)
2599 {
2600 struct headset *hs = dev->headset;
2601
2602 return hs->state;
2603 }
2604
headset_get_channel(struct audio_device * dev)2605 int headset_get_channel(struct audio_device *dev)
2606 {
2607 struct headset *hs = dev->headset;
2608
2609 return hs->rfcomm_ch;
2610 }
2611
headset_is_active(struct audio_device * dev)2612 gboolean headset_is_active(struct audio_device *dev)
2613 {
2614 struct headset *hs = dev->headset;
2615
2616 if (hs->state != HEADSET_STATE_DISCONNECTED)
2617 return TRUE;
2618
2619 return FALSE;
2620 }
2621
headset_get_lock(struct audio_device * dev)2622 headset_lock_t headset_get_lock(struct audio_device *dev)
2623 {
2624 struct headset *hs = dev->headset;
2625
2626 return hs->lock;
2627 }
2628
headset_lock(struct audio_device * dev,headset_lock_t lock)2629 gboolean headset_lock(struct audio_device *dev, headset_lock_t lock)
2630 {
2631 struct headset *hs = dev->headset;
2632
2633 if (hs->lock & lock)
2634 return FALSE;
2635
2636 hs->lock |= lock;
2637
2638 return TRUE;
2639 }
2640
headset_unlock(struct audio_device * dev,headset_lock_t lock)2641 gboolean headset_unlock(struct audio_device *dev, headset_lock_t lock)
2642 {
2643 struct headset *hs = dev->headset;
2644
2645 if (!(hs->lock & lock))
2646 return FALSE;
2647
2648 hs->lock &= ~lock;
2649
2650 if (hs->lock)
2651 return TRUE;
2652
2653 if (hs->state == HEADSET_STATE_PLAYING)
2654 headset_set_state(dev, HEADSET_STATE_CONNECTED);
2655
2656 if (hs->auto_dc) {
2657 if (hs->state == HEADSET_STATE_CONNECTED)
2658 hs->dc_timer = g_timeout_add_seconds(DC_TIMEOUT,
2659 (GSourceFunc) hs_dc_timeout,
2660 dev);
2661 else
2662 headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
2663 }
2664
2665 return TRUE;
2666 }
2667
headset_suspend(struct audio_device * dev,void * data)2668 gboolean headset_suspend(struct audio_device *dev, void *data)
2669 {
2670 return TRUE;
2671 }
2672
headset_play(struct audio_device * dev,void * data)2673 gboolean headset_play(struct audio_device *dev, void *data)
2674 {
2675 return TRUE;
2676 }
2677
headset_get_sco_fd(struct audio_device * dev)2678 int headset_get_sco_fd(struct audio_device *dev)
2679 {
2680 struct headset *hs = dev->headset;
2681
2682 if (!hs->sco)
2683 return -1;
2684
2685 return g_io_channel_unix_get_fd(hs->sco);
2686 }
2687
headset_get_nrec(struct audio_device * dev)2688 gboolean headset_get_nrec(struct audio_device *dev)
2689 {
2690 struct headset *hs = dev->headset;
2691
2692 if (!hs->slc)
2693 return TRUE;
2694
2695 return hs->slc->nrec;
2696 }
2697
headset_add_nrec_cb(struct audio_device * dev,headset_nrec_cb cb,void * user_data)2698 unsigned int headset_add_nrec_cb(struct audio_device *dev,
2699 headset_nrec_cb cb, void *user_data)
2700 {
2701 struct headset *hs = dev->headset;
2702 struct headset_nrec_callback *nrec_cb;
2703 static unsigned int id = 0;
2704
2705 nrec_cb = g_new(struct headset_nrec_callback, 1);
2706 nrec_cb->cb = cb;
2707 nrec_cb->user_data = user_data;
2708 nrec_cb->id = ++id;
2709
2710 hs->nrec_cbs = g_slist_prepend(hs->nrec_cbs, nrec_cb);
2711
2712 return nrec_cb->id;
2713 }
2714
headset_remove_nrec_cb(struct audio_device * dev,unsigned int id)2715 gboolean headset_remove_nrec_cb(struct audio_device *dev, unsigned int id)
2716 {
2717 struct headset *hs = dev->headset;
2718 GSList *l;
2719
2720 for (l = hs->nrec_cbs; l != NULL; l = l->next) {
2721 struct headset_nrec_callback *cb = l->data;
2722 if (cb && cb->id == id) {
2723 hs->nrec_cbs = g_slist_remove(hs->nrec_cbs, cb);
2724 g_free(cb);
2725 return TRUE;
2726 }
2727 }
2728
2729 return FALSE;
2730 }
2731
headset_get_inband(struct audio_device * dev)2732 gboolean headset_get_inband(struct audio_device *dev)
2733 {
2734 struct headset *hs = dev->headset;
2735
2736 if (!hs->slc)
2737 return TRUE;
2738
2739 return hs->slc->inband_ring;
2740 }
2741
headset_get_sco_hci(struct audio_device * dev)2742 gboolean headset_get_sco_hci(struct audio_device *dev)
2743 {
2744 return sco_hci;
2745 }
2746
headset_shutdown(struct audio_device * dev)2747 void headset_shutdown(struct audio_device *dev)
2748 {
2749 struct pending_connect *p = dev->headset->pending;
2750
2751 if (p && p->msg)
2752 error_connect_failed(dev->conn, p->msg, ECANCELED);
2753
2754 pending_connect_finalize(dev);
2755 headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
2756 }
2757
telephony_event_ind(int index)2758 int telephony_event_ind(int index)
2759 {
2760 if (!active_devices)
2761 return -ENODEV;
2762
2763 if (!ag.er_ind) {
2764 DBG("telephony_report_event called but events are disabled");
2765 return -EINVAL;
2766 }
2767
2768 send_foreach_headset(active_devices, hfp_cmp,
2769 "\r\n+CIEV: %d,%d\r\n", index + 1,
2770 ag.indicators[index].val);
2771
2772 return 0;
2773 }
2774
telephony_response_and_hold_ind(int rh)2775 int telephony_response_and_hold_ind(int rh)
2776 {
2777 if (!active_devices)
2778 return -ENODEV;
2779
2780 ag.rh = rh;
2781
2782 /* If we aren't in any response and hold state don't send anything */
2783 if (ag.rh < 0)
2784 return 0;
2785
2786 send_foreach_headset(active_devices, hfp_cmp, "\r\n+BTRH: %d\r\n",
2787 ag.rh);
2788
2789 return 0;
2790 }
2791
telephony_incoming_call_ind(const char * number,int type)2792 int telephony_incoming_call_ind(const char *number, int type)
2793 {
2794 struct audio_device *dev;
2795 struct headset *hs;
2796 struct headset_slc *slc;
2797
2798 if (fast_connectable)
2799 manager_set_fast_connectable(TRUE);
2800
2801 if (!active_devices)
2802 return -ENODEV;
2803
2804 /* Get the latest connected device */
2805 dev = active_devices->data;
2806 hs = dev->headset;
2807 slc = hs->slc;
2808
2809 if (ag.ring_timer) {
2810 DBG("telephony_incoming_call_ind: already calling");
2811 return -EBUSY;
2812 }
2813
2814 /* With HSP 1.2 the RING messages should *not* be sent if inband
2815 * ringtone is being used */
2816 if (!hs->hfp_active && slc->inband_ring)
2817 return 0;
2818
2819 g_free(ag.number);
2820 ag.number = g_strdup(number);
2821 ag.number_type = type;
2822
2823 if (slc->inband_ring && hs->hfp_active &&
2824 hs->state != HEADSET_STATE_PLAYING) {
2825 slc->pending_ring = TRUE;
2826 return 0;
2827 }
2828
2829 ring_timer_cb(NULL);
2830 ag.ring_timer = g_timeout_add_seconds(RING_INTERVAL, ring_timer_cb,
2831 NULL);
2832
2833 return 0;
2834 }
2835
telephony_calling_stopped_ind(void)2836 int telephony_calling_stopped_ind(void)
2837 {
2838 struct audio_device *dev;
2839
2840 if (fast_connectable)
2841 manager_set_fast_connectable(FALSE);
2842
2843 if (ag.ring_timer) {
2844 g_source_remove(ag.ring_timer);
2845 ag.ring_timer = 0;
2846 }
2847
2848 if (!active_devices)
2849 return 0;
2850
2851 /* In case SCO isn't fully up yet */
2852 dev = active_devices->data;
2853
2854 if (!dev->headset->slc->pending_ring && !ag.ring_timer)
2855 return -EINVAL;
2856
2857 dev->headset->slc->pending_ring = FALSE;
2858
2859 return 0;
2860 }
2861
telephony_ready_ind(uint32_t features,const struct indicator * indicators,int rh,const char * chld)2862 int telephony_ready_ind(uint32_t features,
2863 const struct indicator *indicators, int rh,
2864 const char *chld)
2865 {
2866 ag.telephony_ready = TRUE;
2867 ag.features = features;
2868 ag.indicators = indicators;
2869 ag.rh = rh;
2870 ag.chld = chld;
2871
2872 DBG("Telephony plugin initialized");
2873
2874 print_ag_features(ag.features);
2875
2876 return 0;
2877 }
2878
telephony_deinit(void)2879 int telephony_deinit(void)
2880 {
2881 g_free(ag.number);
2882
2883 memset(&ag, 0, sizeof(ag));
2884
2885 ag.er_mode = 3;
2886 ag.rh = BTRH_NOT_SUPPORTED;
2887
2888 DBG("Telephony deinitialized");
2889
2890 return 0;
2891 }
2892
telephony_list_current_call_ind(int idx,int dir,int status,int mode,int mprty,const char * number,int type)2893 int telephony_list_current_call_ind(int idx, int dir, int status, int mode,
2894 int mprty, const char *number,
2895 int type)
2896 {
2897 if (!active_devices)
2898 return -ENODEV;
2899
2900 if (number && strlen(number) > 0)
2901 send_foreach_headset(active_devices, hfp_cmp,
2902 "\r\n+CLCC: %d,%d,%d,%d,%d,\"%s\",%d\r\n",
2903 idx, dir, status, mode, mprty, number, type);
2904 else
2905 send_foreach_headset(active_devices, hfp_cmp,
2906 "\r\n+CLCC: %d,%d,%d,%d,%d\r\n",
2907 idx, dir, status, mode, mprty);
2908
2909 return 0;
2910 }
2911
telephony_subscriber_number_ind(const char * number,int type,int service)2912 int telephony_subscriber_number_ind(const char *number, int type, int service)
2913 {
2914 if (!active_devices)
2915 return -ENODEV;
2916
2917 send_foreach_headset(active_devices, hfp_cmp,
2918 "\r\n+CNUM: ,%s,%d,,%d\r\n",
2919 number, type, service);
2920
2921 return 0;
2922 }
2923
cwa_cmp(struct headset * hs)2924 static int cwa_cmp(struct headset *hs)
2925 {
2926 if (!hs->hfp_active)
2927 return -1;
2928
2929 if (hs->slc->cwa_enabled)
2930 return 0;
2931 else
2932 return -1;
2933 }
2934
telephony_call_waiting_ind(const char * number,int type)2935 int telephony_call_waiting_ind(const char *number, int type)
2936 {
2937 if (!active_devices)
2938 return -ENODEV;
2939
2940 send_foreach_headset(active_devices, cwa_cmp,
2941 "\r\n+CCWA: \"%s\",%d\r\n",
2942 number, type);
2943
2944 return 0;
2945 }
2946
headset_add_state_cb(headset_state_cb cb,void * user_data)2947 unsigned int headset_add_state_cb(headset_state_cb cb, void *user_data)
2948 {
2949 struct headset_state_callback *state_cb;
2950 static unsigned int id = 0;
2951
2952 state_cb = g_new(struct headset_state_callback, 1);
2953 state_cb->cb = cb;
2954 state_cb->user_data = user_data;
2955 state_cb->id = ++id;
2956
2957 headset_callbacks = g_slist_append(headset_callbacks, state_cb);
2958
2959 return state_cb->id;
2960 }
2961
headset_remove_state_cb(unsigned int id)2962 gboolean headset_remove_state_cb(unsigned int id)
2963 {
2964 GSList *l;
2965
2966 for (l = headset_callbacks; l != NULL; l = l->next) {
2967 struct headset_state_callback *cb = l->data;
2968 if (cb && cb->id == id) {
2969 headset_callbacks = g_slist_remove(headset_callbacks, cb);
2970 g_free(cb);
2971 return TRUE;
2972 }
2973 }
2974
2975 return FALSE;
2976 }
2977