On incoming calls don't request a new audio stream. This makes streams collide and...
[empathy.git] / libempathy / empathy-tp-call.c
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3  * Copyright (C) 2007 Elliot Fairweather
4  * Copyright (C) 2007-2008 Collabora Ltd.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * Authors: Elliot Fairweather <elliot.fairweather@collabora.co.uk>
21  *          Xavier Claessens <xclaesse@gmail.com>
22  */
23
24 #include <string.h>
25
26 #include <telepathy-glib/proxy-subclass.h>
27 #include <telepathy-glib/dbus.h>
28 #include <telepathy-glib/interfaces.h>
29
30 #include <extensions/extensions.h>
31
32 #include "empathy-tp-call.h"
33 #include "empathy-contact-factory.h"
34 #include "empathy-tp-group.h"
35 #include "empathy-utils.h"
36
37 #define DEBUG_FLAG EMPATHY_DEBUG_TP
38 #include "empathy-debug.h"
39
40 #define STREAM_ENGINE_BUS_NAME "org.freedesktop.Telepathy.StreamEngine"
41 #define STREAM_ENGINE_OBJECT_PATH "/org/freedesktop/Telepathy/StreamEngine"
42
43 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyTpCall)
44 typedef struct
45 {
46   TpChannel *channel;
47   TpProxy *stream_engine;
48   TpDBusDaemon *dbus_daemon;
49   EmpathyTpGroup *group;
50   EmpathyContact *contact;
51   gboolean is_incoming;
52   guint status;
53   gboolean stream_engine_running;
54
55   EmpathyTpCallStream *audio;
56   EmpathyTpCallStream *video;
57 } EmpathyTpCallPriv;
58
59 enum
60 {
61   PROP_0,
62   PROP_CHANNEL,
63   PROP_CONTACT,
64   PROP_IS_INCOMING,
65   PROP_STATUS,
66   PROP_AUDIO_STREAM,
67   PROP_VIDEO_STREAM
68 };
69
70 G_DEFINE_TYPE (EmpathyTpCall, empathy_tp_call, G_TYPE_OBJECT)
71
72 static void
73 tp_call_add_stream (EmpathyTpCall *call,
74                     guint stream_id,
75                     guint contact_handle,
76                     guint stream_type,
77                     guint stream_state,
78                     guint stream_direction)
79 {
80   EmpathyTpCallPriv *priv = GET_PRIV (call);
81
82   switch (stream_type)
83     {
84       case TP_MEDIA_STREAM_TYPE_AUDIO:
85         DEBUG ("Audio stream - id: %d, state: %d, direction: %d",
86             stream_id, stream_state, stream_direction);
87         priv->audio->exists = TRUE;
88         priv->audio->id = stream_id;
89         priv->audio->state = stream_state;
90         priv->audio->direction = stream_direction;
91         g_object_notify (G_OBJECT (call), "audio-stream");
92         break;
93       case TP_MEDIA_STREAM_TYPE_VIDEO:
94         DEBUG ("Video stream - id: %d, state: %d, direction: %d",
95             stream_id, stream_state, stream_direction);
96         priv->video->exists = TRUE;
97         priv->video->id = stream_id;
98         priv->video->state = stream_state;
99         priv->video->direction = stream_direction;
100         g_object_notify (G_OBJECT (call), "video-stream");
101         break;
102       default:
103         DEBUG ("Unknown stream type: %d", stream_type);
104     }
105 }
106
107 static void
108 tp_call_stream_added_cb (TpChannel *channel,
109                          guint stream_id,
110                          guint contact_handle,
111                          guint stream_type,
112                          gpointer user_data,
113                          GObject *call)
114 {
115   DEBUG ("Stream added - stream id: %d, contact handle: %d, stream type: %d",
116       stream_id, contact_handle, stream_type);
117
118   tp_call_add_stream (EMPATHY_TP_CALL (call), stream_id, contact_handle,
119       stream_type, TP_MEDIA_STREAM_STATE_DISCONNECTED,
120       TP_MEDIA_STREAM_DIRECTION_NONE);
121 }
122
123 static void
124 tp_call_stream_removed_cb (TpChannel *channel,
125                            guint stream_id,
126                            gpointer user_data,
127                            GObject *call)
128 {
129   EmpathyTpCallPriv *priv = GET_PRIV (call);
130
131   DEBUG ("Stream removed - stream id: %d", stream_id);
132
133   if (stream_id == priv->audio->id)
134     {
135       priv->audio->exists = FALSE;
136       g_object_notify (call, "audio-stream");
137     }
138   else if (stream_id == priv->video->id)
139     {
140       priv->video->exists = FALSE;
141       g_object_notify (call, "video-stream");
142     }
143 }
144
145 static void
146 tp_call_stream_state_changed_cb (TpChannel *proxy,
147                                  guint stream_id,
148                                  guint stream_state,
149                                  gpointer user_data,
150                                  GObject *call)
151 {
152   EmpathyTpCallPriv *priv = GET_PRIV (call);
153
154   DEBUG ("Stream state changed - stream id: %d, state state: %d",
155       stream_id, stream_state);
156
157   if (stream_id == priv->audio->id)
158     {
159       priv->audio->state = stream_state;
160       g_object_notify (call, "audio-stream");
161     }
162   else if (stream_id == priv->video->id)
163     {
164       priv->video->state = stream_state;
165       g_object_notify (call, "video-stream");
166     }
167 }
168
169 static void
170 tp_call_stream_direction_changed_cb (TpChannel *channel,
171                                      guint stream_id,
172                                      guint stream_direction,
173                                      guint pending_flags,
174                                      gpointer user_data,
175                                      GObject *call)
176 {
177   EmpathyTpCallPriv *priv = GET_PRIV (call);
178
179   DEBUG ("Stream direction changed - stream: %d, direction: %d",
180       stream_id, stream_direction);
181
182   if (stream_id == priv->audio->id)
183     {
184       priv->audio->direction = stream_direction;
185       g_object_notify (call, "audio-stream");
186     }
187   else if (stream_id == priv->video->id)
188     {
189       priv->video->direction = stream_direction;
190       g_object_notify (call, "video-stream");
191     }
192 }
193
194 static void
195 tp_call_request_streams_cb (TpChannel *channel,
196                             const GPtrArray *streams,
197                             const GError *error,
198                             gpointer user_data,
199                             GObject *call)
200 {
201   guint i;
202
203   if (error)
204     {
205       DEBUG ("Error requesting streams: %s", error->message);
206       return;
207     }
208
209   for (i = 0; i < streams->len; i++)
210     {
211       GValueArray *values;
212       guint stream_id;
213       guint contact_handle;
214       guint stream_type;
215       guint stream_state;
216       guint stream_direction;
217
218       values = g_ptr_array_index (streams, i);
219       stream_id = g_value_get_uint (g_value_array_get_nth (values, 0));
220       contact_handle = g_value_get_uint (g_value_array_get_nth (values, 1));
221       stream_type = g_value_get_uint (g_value_array_get_nth (values, 2));
222       stream_state = g_value_get_uint (g_value_array_get_nth (values, 3));
223       stream_direction = g_value_get_uint (g_value_array_get_nth (values, 4));
224
225       tp_call_add_stream (EMPATHY_TP_CALL (call), stream_id, contact_handle,
226           stream_type, stream_state, stream_direction);
227   }
228 }
229
230 static void
231 tp_call_request_streams_for_capabilities (EmpathyTpCall *call,
232                                           EmpathyCapabilities capabilities)
233 {
234   EmpathyTpCallPriv *priv = GET_PRIV (call);
235   GArray *stream_types;
236   guint handle;
237   guint stream_type;
238
239   if (capabilities == EMPATHY_CAPABILITIES_UNKNOWN)
240       capabilities = EMPATHY_CAPABILITIES_AUDIO | EMPATHY_CAPABILITIES_VIDEO;
241
242   DEBUG ("Requesting new stream for capabilities %d",
243       capabilities);
244
245   stream_types = g_array_new (FALSE, FALSE, sizeof (guint));
246   handle = empathy_contact_get_handle (priv->contact);
247
248   if (capabilities & EMPATHY_CAPABILITIES_AUDIO)
249     {
250       stream_type = TP_MEDIA_STREAM_TYPE_AUDIO;
251       g_array_append_val (stream_types, stream_type);
252     }
253   if (capabilities & EMPATHY_CAPABILITIES_VIDEO)
254     {
255       stream_type = TP_MEDIA_STREAM_TYPE_VIDEO;
256       g_array_append_val (stream_types, stream_type);
257     }
258
259   tp_cli_channel_type_streamed_media_call_request_streams (priv->channel, -1,
260       handle, stream_types, tp_call_request_streams_cb, NULL, NULL,
261       G_OBJECT (call));
262
263   g_array_free (stream_types, TRUE);
264 }
265
266 static void
267 tp_call_member_added_cb (EmpathyTpGroup *group,
268                          EmpathyContact *contact,
269                          EmpathyContact *actor,
270                          guint reason,
271                          const gchar *message,
272                          EmpathyTpCall *call)
273 {
274   EmpathyTpCallPriv *priv = GET_PRIV (call);
275
276   g_object_ref (call);
277   if (!priv->contact && !empathy_contact_is_user (contact))
278     {
279       priv->contact = g_object_ref (contact);
280       priv->is_incoming = TRUE;
281       priv->status = EMPATHY_TP_CALL_STATUS_PENDING;
282       g_object_notify (G_OBJECT (call), "is-incoming");
283       g_object_notify (G_OBJECT (call), "contact");
284       g_object_notify (G_OBJECT (call), "status");
285     }
286
287   if (priv->status == EMPATHY_TP_CALL_STATUS_PENDING &&
288       ((priv->is_incoming && contact != priv->contact) ||
289        (!priv->is_incoming && contact == priv->contact)))
290     {
291       priv->status = EMPATHY_TP_CALL_STATUS_ACCEPTED;
292       g_object_notify (G_OBJECT (call), "status");
293     }
294   g_object_unref (call);
295 }
296
297 static void
298 tp_call_remote_pending_cb (EmpathyTpGroup *group,
299                            EmpathyContact *contact,
300                            EmpathyContact *actor,
301                            guint reason,
302                            const gchar *message,
303                            EmpathyTpCall *call)
304 {
305   EmpathyTpCallPriv *priv = GET_PRIV (call);
306
307   g_object_ref (call);
308   if (!priv->contact && !empathy_contact_is_user (contact))
309     {
310       priv->contact = g_object_ref (contact);
311       priv->is_incoming = FALSE;
312       priv->status = EMPATHY_TP_CALL_STATUS_PENDING;
313       g_object_notify (G_OBJECT (call), "is-incoming");
314       g_object_notify (G_OBJECT (call), "contact"); 
315       g_object_notify (G_OBJECT (call), "status");      
316       tp_call_request_streams_for_capabilities (call,
317           EMPATHY_CAPABILITIES_AUDIO);
318     }
319   g_object_unref (call);
320 }
321
322 static void
323 tp_call_channel_invalidated_cb (TpChannel     *channel,
324                                 GQuark         domain,
325                                 gint           code,
326                                 gchar         *message,
327                                 EmpathyTpCall *call)
328 {
329   EmpathyTpCallPriv *priv = GET_PRIV (call);
330
331   DEBUG ("Channel invalidated: %s", message);
332   priv->status = EMPATHY_TP_CALL_STATUS_CLOSED;
333   g_object_notify (G_OBJECT (call), "status");
334 }
335
336 static void
337 tp_call_async_cb (TpProxy *proxy,
338                   const GError *error,
339                   gpointer user_data,
340                   GObject *call)
341 {
342   if (error)
343       DEBUG ("Error %s: %s", (gchar*) user_data, error->message);
344 }
345
346 static void
347 tp_call_close_channel (EmpathyTpCall *call)
348 {
349   EmpathyTpCallPriv *priv = GET_PRIV (call);
350
351   if (priv->status == EMPATHY_TP_CALL_STATUS_CLOSED)
352       return;
353
354   DEBUG ("Closing channel");
355
356   tp_cli_channel_call_close (priv->channel, -1,
357       NULL, NULL, NULL, NULL);
358
359   priv->status = EMPATHY_TP_CALL_STATUS_CLOSED;
360   g_object_notify (G_OBJECT (call), "status");
361 }
362
363 static void
364 tp_call_stream_engine_invalidated_cb (TpProxy       *stream_engine,
365                                       GQuark         domain,
366                                       gint           code,
367                                       gchar         *message,
368                                       EmpathyTpCall *call)
369 {
370   DEBUG ("Stream engine proxy invalidated: %s", message);
371   tp_call_close_channel (call);
372 }
373
374 static void
375 tp_call_stream_engine_watch_name_owner_cb (TpDBusDaemon *daemon,
376                                            const gchar *name,
377                                            const gchar *new_owner,
378                                            gpointer call)
379 {
380   EmpathyTpCallPriv *priv = GET_PRIV (call);
381
382   /* G_STR_EMPTY(new_owner) means either stream-engine has not started yet or
383    * has crashed. We want to close the channel if stream-engine has crashed.
384    * */
385   DEBUG ("Watch SE: name='%s' SE running='%s' new_owner='%s'",
386       name, priv->stream_engine_running ? "yes" : "no",
387       new_owner ? new_owner : "none");
388   if (priv->stream_engine_running && G_STR_EMPTY (new_owner))
389     {
390       DEBUG ("Stream engine falled off the bus");
391       tp_call_close_channel (call);
392       return;
393     }
394
395   priv->stream_engine_running = !G_STR_EMPTY (new_owner);
396 }
397
398 static void
399 tp_call_stream_engine_handle_channel (EmpathyTpCall *call)
400 {
401   EmpathyTpCallPriv *priv = GET_PRIV (call);
402   gchar *channel_type;
403   gchar *object_path;
404   guint handle_type;
405   guint handle;
406   TpProxy *connection;
407
408   DEBUG ("Revving up the stream engine");
409
410   priv->stream_engine = g_object_new (TP_TYPE_PROXY,
411       "bus-name", STREAM_ENGINE_BUS_NAME,
412       "dbus-connection", tp_get_bus (),
413       "object-path", STREAM_ENGINE_OBJECT_PATH,
414        NULL);
415   tp_proxy_add_interface_by_id (priv->stream_engine,
416       EMP_IFACE_QUARK_STREAM_ENGINE);
417   tp_proxy_add_interface_by_id (priv->stream_engine,
418       EMP_IFACE_QUARK_CHANNEL_HANDLER);
419
420   g_signal_connect (priv->stream_engine, "invalidated",
421       G_CALLBACK (tp_call_stream_engine_invalidated_cb),
422       call);
423   
424   /* FIXME: dbus daemon should be unique */
425   priv->dbus_daemon = tp_dbus_daemon_new (tp_get_bus ());
426   tp_dbus_daemon_watch_name_owner (priv->dbus_daemon, STREAM_ENGINE_BUS_NAME,
427       tp_call_stream_engine_watch_name_owner_cb,
428       call, NULL);
429
430   g_object_get (priv->channel,
431       "connection", &connection,
432       "channel-type", &channel_type,
433       "object-path", &object_path,
434       "handle_type", &handle_type,
435       "handle", &handle,
436       NULL);
437
438   emp_cli_channel_handler_call_handle_channel (priv->stream_engine, -1,
439         connection->bus_name,
440         connection->object_path,
441         channel_type, object_path, handle_type, handle,
442         tp_call_async_cb, "calling handle channel", NULL,
443         G_OBJECT (call));
444
445   g_object_unref (connection);
446   g_free (channel_type);
447   g_free (object_path);
448 }
449
450 static GObject *
451 tp_call_constructor (GType type,
452                      guint n_construct_params,
453                      GObjectConstructParam *construct_params)
454 {
455   GObject *object;
456   EmpathyTpCall *call;
457   EmpathyTpCallPriv *priv;
458
459   object = G_OBJECT_CLASS (empathy_tp_call_parent_class)->constructor (type,
460       n_construct_params, construct_params);
461
462   call = EMPATHY_TP_CALL (object);
463   priv = GET_PRIV (call);
464
465   /* Setup streamed media channel */
466   g_signal_connect (priv->channel, "invalidated",
467       G_CALLBACK (tp_call_channel_invalidated_cb), call);
468   tp_cli_channel_type_streamed_media_connect_to_stream_added (priv->channel,
469       tp_call_stream_added_cb, NULL, NULL, G_OBJECT (call), NULL);
470   tp_cli_channel_type_streamed_media_connect_to_stream_removed (priv->channel,
471       tp_call_stream_removed_cb, NULL, NULL, G_OBJECT (call), NULL);
472   tp_cli_channel_type_streamed_media_connect_to_stream_state_changed (priv->channel,
473       tp_call_stream_state_changed_cb, NULL, NULL, G_OBJECT (call), NULL);
474   tp_cli_channel_type_streamed_media_connect_to_stream_direction_changed (priv->channel,
475       tp_call_stream_direction_changed_cb, NULL, NULL, G_OBJECT (call), NULL);
476   tp_cli_channel_type_streamed_media_call_list_streams (priv->channel, -1,
477       tp_call_request_streams_cb, NULL, NULL, G_OBJECT (call));
478
479   /* Setup group interface */
480   priv->group = empathy_tp_group_new (priv->channel);
481
482   g_signal_connect (priv->group, "member-added",
483       G_CALLBACK (tp_call_member_added_cb), call);
484   g_signal_connect (priv->group, "remote-pending",
485       G_CALLBACK (tp_call_remote_pending_cb), call);
486
487   /* Start stream engine */
488   tp_call_stream_engine_handle_channel (call);
489
490   return object;
491 }
492
493 static void 
494 tp_call_finalize (GObject *object)
495 {
496   EmpathyTpCallPriv *priv = GET_PRIV (object);
497
498   DEBUG ("Finalizing: %p", object);
499
500   g_slice_free (EmpathyTpCallStream, priv->audio);
501   g_slice_free (EmpathyTpCallStream, priv->video);
502   g_object_unref (priv->group);
503
504   if (priv->channel != NULL)
505     {
506       g_signal_handlers_disconnect_by_func (priv->channel,
507           tp_call_channel_invalidated_cb, object);
508       tp_call_close_channel (EMPATHY_TP_CALL (object));
509       g_object_unref (priv->channel);
510     }
511
512   if (priv->stream_engine != NULL)
513     {
514       g_signal_handlers_disconnect_by_func (priv->stream_engine,
515           tp_call_stream_engine_invalidated_cb, object);
516       g_object_unref (priv->stream_engine);
517     }
518
519   if (priv->contact != NULL)
520       g_object_unref (priv->contact);
521
522   if (priv->dbus_daemon != NULL)
523     {
524       tp_dbus_daemon_cancel_name_owner_watch (priv->dbus_daemon,
525           STREAM_ENGINE_BUS_NAME,
526           tp_call_stream_engine_watch_name_owner_cb,
527           object);
528       g_object_unref (priv->dbus_daemon);
529     }
530
531   (G_OBJECT_CLASS (empathy_tp_call_parent_class)->finalize) (object);
532 }
533
534 static void 
535 tp_call_set_property (GObject *object,
536                       guint prop_id,
537                       const GValue *value,
538                       GParamSpec *pspec)
539 {
540   EmpathyTpCallPriv *priv = GET_PRIV (object);
541
542   switch (prop_id)
543     {
544     case PROP_CHANNEL:
545       priv->channel = g_value_dup_object (value);
546       break;
547     default:
548       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
549       break;
550   }
551 }
552
553 static void
554 tp_call_get_property (GObject *object,
555                       guint prop_id,
556                       GValue *value,
557                       GParamSpec *pspec)
558 {
559   EmpathyTpCallPriv *priv = GET_PRIV (object);
560
561   switch (prop_id)
562     {
563     case PROP_CHANNEL:
564       g_value_set_object (value, priv->channel);
565       break;
566     case PROP_CONTACT:
567       g_value_set_object (value, priv->contact);
568       break;
569     case PROP_IS_INCOMING:
570       g_value_set_boolean (value, priv->is_incoming);
571       break;
572     case PROP_STATUS:
573       g_value_set_uint (value, priv->status);
574       break;
575     case PROP_AUDIO_STREAM:
576       g_value_set_pointer (value, priv->audio);
577       break;
578     case PROP_VIDEO_STREAM:
579       g_value_set_pointer (value, priv->video);
580       break;
581     default:
582       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
583       break;
584   }
585 }
586
587 static void
588 empathy_tp_call_class_init (EmpathyTpCallClass *klass)
589 {
590   GObjectClass *object_class = G_OBJECT_CLASS (klass);
591
592   emp_cli_init ();
593
594   object_class->constructor = tp_call_constructor;
595   object_class->finalize = tp_call_finalize;
596   object_class->set_property = tp_call_set_property;
597   object_class->get_property = tp_call_get_property;
598
599   g_type_class_add_private (klass, sizeof (EmpathyTpCallPriv));
600
601   g_object_class_install_property (object_class, PROP_CHANNEL,
602       g_param_spec_object ("channel", "channel", "channel",
603       TP_TYPE_CHANNEL,
604       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
605       G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
606   g_object_class_install_property (object_class, PROP_CONTACT,
607       g_param_spec_object ("contact", "Call contact", "Call contact",
608       EMPATHY_TYPE_CONTACT,
609       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
610   g_object_class_install_property (object_class, PROP_IS_INCOMING,
611       g_param_spec_boolean ("is-incoming", "Is media stream incoming",
612       "Is media stream incoming", FALSE, G_PARAM_READABLE |
613       G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
614   g_object_class_install_property (object_class, PROP_STATUS,
615       g_param_spec_uint ("status", "Call status",
616       "Call status", 0, 255, 0, G_PARAM_READABLE | G_PARAM_STATIC_NICK |
617       G_PARAM_STATIC_BLURB));
618   g_object_class_install_property (object_class, PROP_AUDIO_STREAM,
619       g_param_spec_pointer ("audio-stream", "Audio stream data",
620       "Audio stream data",
621       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
622   g_object_class_install_property (object_class, PROP_VIDEO_STREAM,
623       g_param_spec_pointer ("video-stream", "Video stream data",
624       "Video stream data",
625       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
626 }
627
628 static void
629 empathy_tp_call_init (EmpathyTpCall *call)
630 {
631   EmpathyTpCallPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (call,
632                 EMPATHY_TYPE_TP_CALL, EmpathyTpCallPriv);
633
634   call->priv = priv;
635   priv->status = EMPATHY_TP_CALL_STATUS_READYING;
636   priv->contact = NULL;
637   priv->stream_engine_running = FALSE;
638   priv->audio = g_slice_new0 (EmpathyTpCallStream);
639   priv->video = g_slice_new0 (EmpathyTpCallStream);
640   priv->audio->exists = FALSE;
641   priv->video->exists = FALSE;
642 }
643
644 EmpathyTpCall *
645 empathy_tp_call_new (TpChannel *channel)
646 {
647   g_return_val_if_fail (TP_IS_CHANNEL (channel), NULL);
648
649   return g_object_new (EMPATHY_TYPE_TP_CALL,
650       "channel", channel,
651       NULL);
652 }
653
654 void
655 empathy_tp_call_accept_incoming_call (EmpathyTpCall *call)
656 {
657   EmpathyTpCallPriv *priv = GET_PRIV (call);
658   EmpathyContact *self_contact;
659
660   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
661   g_return_if_fail (priv->status == EMPATHY_TP_CALL_STATUS_PENDING);
662
663   DEBUG ("Accepting incoming call");
664
665   self_contact = empathy_tp_group_get_self_contact (priv->group);
666   empathy_tp_group_add_member (priv->group, self_contact, NULL);
667   g_object_unref (self_contact);
668 }
669
670 void
671 empathy_tp_call_request_video_stream_direction (EmpathyTpCall *call,
672                                                 gboolean is_sending)
673 {
674   EmpathyTpCallPriv *priv = GET_PRIV (call);
675   guint new_direction;
676
677   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
678   g_return_if_fail (priv->status == EMPATHY_TP_CALL_STATUS_ACCEPTED);
679
680   DEBUG ("Requesting video stream direction - is_sending: %d", is_sending);
681
682   if (!priv->video->exists)
683     {
684       if (is_sending)
685           tp_call_request_streams_for_capabilities (call,
686               EMPATHY_CAPABILITIES_VIDEO);
687       return;
688     }
689
690   if (is_sending)
691       new_direction = priv->video->direction | TP_MEDIA_STREAM_DIRECTION_SEND;
692   else
693       new_direction = priv->video->direction & ~TP_MEDIA_STREAM_DIRECTION_SEND;
694
695   tp_cli_channel_type_streamed_media_call_request_stream_direction (priv->channel,
696       -1, priv->video->id, new_direction,
697       (tp_cli_channel_type_streamed_media_callback_for_request_stream_direction)
698       tp_call_async_cb, NULL, NULL, G_OBJECT (call));
699 }
700
701 void
702 empathy_tp_call_add_preview_video (EmpathyTpCall *call,
703                                    guint preview_video_socket_id)
704 {
705   EmpathyTpCallPriv *priv = GET_PRIV (call);
706
707   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
708
709   DEBUG ("Adding preview video");
710
711   emp_cli_stream_engine_call_add_preview_window (priv->stream_engine, -1,
712       preview_video_socket_id,
713       tp_call_async_cb,
714       "adding preview window", NULL,
715       G_OBJECT (call));
716 }
717
718 void
719 empathy_tp_call_remove_preview_video (EmpathyTpCall *call,
720                                       guint preview_video_socket_id)
721 {
722   EmpathyTpCallPriv *priv = GET_PRIV (call);
723
724   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
725
726   DEBUG ("Removing preview video");
727
728   emp_cli_stream_engine_call_remove_preview_window (priv->stream_engine, -1,
729       preview_video_socket_id,
730       tp_call_async_cb,
731       "removing preview window", NULL,
732       G_OBJECT (call));
733 }
734
735 void
736 empathy_tp_call_add_output_video (EmpathyTpCall *call,
737                                   guint output_video_socket_id)
738 {
739   EmpathyTpCallPriv *priv = GET_PRIV (call);
740
741   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
742
743   DEBUG ("Adding output video - socket: %d", output_video_socket_id);
744
745   emp_cli_stream_engine_call_set_output_window (priv->stream_engine, -1,
746       TP_PROXY (priv->channel)->object_path,
747       priv->video->id, output_video_socket_id,
748       tp_call_async_cb,
749       "setting output window", NULL,
750       G_OBJECT (call));
751 }
752
753 void
754 empathy_tp_call_set_output_volume (EmpathyTpCall *call,
755                                    guint volume)
756 {
757   EmpathyTpCallPriv *priv = GET_PRIV (call);
758
759   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
760   g_return_if_fail (priv->status != EMPATHY_TP_CALL_STATUS_CLOSED);
761
762   DEBUG ("Setting output volume: %d", volume);
763
764   emp_cli_stream_engine_call_set_output_volume (priv->stream_engine, -1,
765       TP_PROXY (priv->channel)->object_path,
766       priv->audio->id, volume,
767       tp_call_async_cb,
768       "setting output volume", NULL,
769       G_OBJECT (call));
770 }
771
772 void
773 empathy_tp_call_mute_output (EmpathyTpCall *call,
774                              gboolean is_muted)
775 {
776   EmpathyTpCallPriv *priv = GET_PRIV (call);
777
778   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
779
780   DEBUG ("Setting output mute: %d", is_muted);
781
782   emp_cli_stream_engine_call_mute_output (priv->stream_engine, -1,
783       TP_PROXY (priv->channel)->object_path,
784       priv->audio->id, is_muted,
785       tp_call_async_cb,
786       "muting output", NULL,
787       G_OBJECT (call));
788 }
789
790 void
791 empathy_tp_call_mute_input (EmpathyTpCall *call,
792                             gboolean is_muted)
793 {
794   EmpathyTpCallPriv *priv = GET_PRIV (call);
795
796   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
797
798   DEBUG ("Setting input mute: %d", is_muted);
799
800   emp_cli_stream_engine_call_mute_input (priv->stream_engine, -1,
801       TP_PROXY (priv->channel)->object_path,
802       priv->audio->id, is_muted,
803       tp_call_async_cb,
804       "muting input", NULL,
805       G_OBJECT (call));
806 }
807
808 void
809 empathy_tp_call_start_tone (EmpathyTpCall *call, TpDTMFEvent event)
810 {
811   EmpathyTpCallPriv *priv = GET_PRIV (call);
812
813   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
814   g_return_if_fail (priv->status == EMPATHY_TP_CALL_STATUS_ACCEPTED);
815
816   if (!priv->audio->exists)
817       return;
818
819   tp_cli_channel_interface_dtmf_call_start_tone (priv->channel, -1,
820       priv->audio->id, event,
821       (tp_cli_channel_interface_dtmf_callback_for_start_tone) tp_call_async_cb,
822       "starting tone", NULL, G_OBJECT (call));
823 }
824
825 void
826 empathy_tp_call_stop_tone (EmpathyTpCall *call)
827 {
828   EmpathyTpCallPriv *priv = GET_PRIV (call);
829
830   g_return_if_fail (EMPATHY_IS_TP_CALL (call));
831   g_return_if_fail (priv->status == EMPATHY_TP_CALL_STATUS_ACCEPTED);
832
833   if (!priv->audio->exists)
834       return;
835
836   tp_cli_channel_interface_dtmf_call_stop_tone (priv->channel, -1,
837       priv->audio->id,
838       (tp_cli_channel_interface_dtmf_callback_for_stop_tone) tp_call_async_cb,
839       "stoping tone", NULL, G_OBJECT (call));
840 }
841
842 gboolean
843 empathy_tp_call_has_dtmf (EmpathyTpCall *call)
844 {
845   EmpathyTpCallPriv *priv = GET_PRIV (call);
846
847   g_return_val_if_fail (EMPATHY_IS_TP_CALL (call), FALSE);
848
849   return tp_proxy_has_interface_by_id (priv->channel,
850       TP_IFACE_QUARK_CHANNEL_INTERFACE_DTMF);
851 }
852