6dd24a51a34c193baa8bb303a4697b8d76034dcf
[empathy.git] / libempathy / empathy-tp-call.c
1 /*
2  *  Copyright (C) 2007 Elliot Fairweather
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Lesser General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2.1 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Lesser General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Lesser General Public
15  *  License along with this library; if not, write to the Free Software
16  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  *
18  *  Authors: Elliot Fairweather <elliot.fairweather@collabora.co.uk>
19  */
20
21 #include <string.h>
22 #include <dbus/dbus-glib.h>
23
24 #include <libtelepathy/tp-chan-type-streamed-media-gen.h>
25 #include <libtelepathy/tp-connmgr.h>
26 #include <libtelepathy/tp-helpers.h>
27 #include <telepathy-glib/proxy-subclass.h>
28
29 #include <libmissioncontrol/mc-account.h>
30
31 #include <extensions/extensions.h>
32 #include <libempathy/empathy-contact-factory.h>
33 #include <libempathy/empathy-debug.h>
34 #include <libempathy/empathy-tp-group.h>
35 #include <libempathy/empathy-utils.h>
36
37 #include "empathy-tp-call.h"
38
39 #define DEBUG_DOMAIN "TpCall"
40
41 #define GET_PRIV(object) (G_TYPE_INSTANCE_GET_PRIVATE \
42     ((object), EMPATHY_TYPE_TP_CALL, EmpathyTpCallPriv))
43
44 #define STREAM_ENGINE_BUS_NAME "org.freedesktop.Telepathy.StreamEngine"
45 #define STREAM_ENGINE_OBJECT_PATH "/org/freedesktop/Telepathy/StreamEngine"
46
47 typedef struct _EmpathyTpCallPriv EmpathyTpCallPriv;
48
49 struct _EmpathyTpCallPriv
50 {
51   TpConn *connection;
52   TpChan *channel;
53   TpProxy *stream_engine;
54   EmpathyTpGroup *group;
55   EmpathyContact *contact;
56   gboolean is_incoming;
57   guint status;
58
59   EmpathyTpCallStream *audio;
60   EmpathyTpCallStream *video;
61 };
62
63 enum
64 {
65   STATUS_CHANGED_SIGNAL,
66   RECEIVING_VIDEO_SIGNAL,
67   SENDING_VIDEO_SIGNAL,
68   LAST_SIGNAL
69 };
70
71 enum
72 {
73   PROP_0,
74   PROP_CONNECTION,
75   PROP_CHANNEL,
76   PROP_CONTACT,
77   PROP_IS_INCOMING,
78   PROP_STATUS,
79   PROP_AUDIO_STREAM,
80   PROP_VIDEO_STREAM
81 };
82
83 static guint signals[LAST_SIGNAL];
84
85 G_DEFINE_TYPE (EmpathyTpCall, empathy_tp_call, G_TYPE_OBJECT)
86
87 static void
88 tp_call_stream_state_changed_cb (DBusGProxy *channel,
89                                  guint stream_id,
90                                  guint stream_state,
91                                  EmpathyTpCall *call)
92 {
93   EmpathyTpCallPriv *priv = GET_PRIV (call);
94
95   empathy_debug (DEBUG_DOMAIN,
96       "Stream state changed - stream id: %d, state state: %d",
97       stream_id, stream_state);
98
99   if (stream_id == priv->audio->id)
100     {
101       priv->audio->state = stream_state;
102     }
103   else if (stream_id == priv->video->id)
104     {
105       priv->video->state = stream_state;
106     }
107
108   g_signal_emit_by_name (call, "status-changed");
109 }
110
111 static void
112 tp_call_identify_streams (EmpathyTpCall *call)
113 {
114   EmpathyTpCallPriv *priv = GET_PRIV (call);
115   GPtrArray *stream_infos;
116   DBusGProxy *streamed_iface;
117   GError *error = NULL;
118   guint i;
119
120   empathy_debug (DEBUG_DOMAIN, "Identifying audio/video streams");
121
122   streamed_iface = tp_chan_get_interface (priv->channel,
123       TELEPATHY_CHAN_IFACE_STREAMED_QUARK);
124
125   if (!tp_chan_type_streamed_media_list_streams (streamed_iface, &stream_infos,
126         &error))
127     {
128       empathy_debug (DEBUG_DOMAIN, "Couldn't list audio/video streams: %s",
129           error->message);
130       g_clear_error (&error);
131       return;
132     }
133
134   for (i = 0; i < stream_infos->len; i++)
135     {
136       GValueArray *values;
137       guint stream_id;
138       guint stream_handle;
139       guint stream_type;
140       guint stream_state;
141       guint stream_direction;
142
143       values = g_ptr_array_index (stream_infos, i);
144       stream_id = g_value_get_uint (g_value_array_get_nth (values, 0));
145       stream_handle = g_value_get_uint (g_value_array_get_nth (values, 1));
146       stream_type = g_value_get_uint (g_value_array_get_nth (values, 2));
147       stream_state = g_value_get_uint (g_value_array_get_nth (values, 3));
148       stream_direction = g_value_get_uint (g_value_array_get_nth (values, 4));
149
150       switch (stream_type)
151         {
152         case TP_MEDIA_STREAM_TYPE_AUDIO:
153           empathy_debug (DEBUG_DOMAIN,
154               "Audio stream - id: %d, state: %d, direction: %d",
155               stream_id, stream_state, stream_direction);
156           priv->audio->exists = TRUE;
157           priv->audio->id = stream_id;
158           priv->audio->state = stream_state;
159           priv->audio->direction = stream_direction;
160           break;
161         case TP_MEDIA_STREAM_TYPE_VIDEO:
162           empathy_debug (DEBUG_DOMAIN,
163               "Video stream - id: %d, state: %d, direction: %d",
164               stream_id, stream_state, stream_direction);
165           priv->video->exists = TRUE;
166           priv->video->id = stream_id;
167           priv->video->state = stream_state;
168           priv->video->direction = stream_direction;
169           break;
170         default:
171           empathy_debug (DEBUG_DOMAIN, "Unknown stream type: %d",
172               stream_type);
173         }
174
175       g_value_array_free (values);
176     }
177 }
178
179 static void
180 tp_call_stream_added_cb (DBusGProxy *channel,
181                          guint stream_id,
182                          guint contact_handle,
183                          guint stream_type,
184                          EmpathyTpCall *call)
185 {
186   empathy_debug (DEBUG_DOMAIN,
187       "Stream added - stream id: %d, contact handle: %d, stream type: %d",
188       stream_id, contact_handle, stream_type);
189
190   tp_call_identify_streams (call);
191 }
192
193
194 static void
195 tp_call_stream_removed_cb (DBusGProxy *channel,
196                            guint stream_id,
197                            EmpathyTpCall *call)
198 {
199   EmpathyTpCallPriv *priv = GET_PRIV (call);
200
201   empathy_debug (DEBUG_DOMAIN, "Stream removed - stream id: %d", stream_id);
202
203   if (stream_id == priv->audio->id)
204     {
205       priv->audio->exists = FALSE;
206     }
207   else if (stream_id == priv->video->id)
208     {
209       priv->video->exists = FALSE;
210     }
211 }
212
213 static void
214 tp_call_channel_closed_cb (TpChan *channel,
215                            EmpathyTpCall *call)
216 {
217   EmpathyTpCallPriv *priv = GET_PRIV (call);
218   DBusGProxy *streamed_iface;
219   DBusGProxy *group_iface;
220
221   empathy_debug (DEBUG_DOMAIN, "Channel closed");
222
223   priv->status = EMPATHY_TP_CALL_STATUS_CLOSED;
224   g_signal_emit_by_name (call, "status-changed");
225
226   streamed_iface = tp_chan_get_interface (priv->channel,
227       TELEPATHY_CHAN_IFACE_STREAMED_QUARK);
228   group_iface = tp_chan_get_interface (priv->channel,
229       TELEPATHY_CHAN_IFACE_GROUP_QUARK);
230
231   dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->channel), "Closed",
232       G_CALLBACK (tp_call_channel_closed_cb), (gpointer) call);
233   dbus_g_proxy_disconnect_signal (streamed_iface, "StreamStateChanged",
234       G_CALLBACK (tp_call_stream_state_changed_cb), (gpointer) call);
235   dbus_g_proxy_disconnect_signal (streamed_iface, "StreamAdded",
236       G_CALLBACK (tp_call_stream_added_cb), (gpointer) call);
237   dbus_g_proxy_disconnect_signal (streamed_iface, "StreamRemoved",
238       G_CALLBACK (tp_call_stream_removed_cb), (gpointer) call);
239 }
240
241 static void
242 tp_call_stream_direction_changed_cb (DBusGProxy *channel,
243                                      guint stream_id,
244                                      guint stream_direction,
245                                      guint flags,
246                                      EmpathyTpCall *call)
247 {
248   EmpathyTpCallPriv *priv = GET_PRIV (call);
249
250   empathy_debug (DEBUG_DOMAIN,
251       "Stream direction changed - stream: %d, direction: %d",
252       stream_id, stream_direction);
253
254   if (stream_id == priv->audio->id)
255     {
256       priv->audio->direction = stream_direction;
257     }
258   else if (stream_id == priv->video->id)
259     {
260       priv->video->direction = stream_direction;
261
262       if (stream_direction & TP_MEDIA_STREAM_DIRECTION_RECEIVE)
263         {
264           empathy_debug (DEBUG_DOMAIN, "RECEIVING");
265           g_signal_emit_by_name (call, "receiving-video", TRUE);
266         }
267       else
268         {
269           empathy_debug (DEBUG_DOMAIN, "NOT RECEIVING");
270           g_signal_emit_by_name (call, "receiving-video", FALSE);
271         }
272
273       if (stream_direction & TP_MEDIA_STREAM_DIRECTION_SEND)
274         {
275           empathy_debug (DEBUG_DOMAIN, "SENDING");
276           g_signal_emit_by_name (call, "sending-video", TRUE);
277         }
278       else
279         {
280           empathy_debug (DEBUG_DOMAIN, "NOT SENDING");
281           g_signal_emit_by_name (call, "sending-video", FALSE);
282         }
283     }
284 }
285
286 static void
287 tp_call_request_streams_for_capabilities (EmpathyTpCall *call,
288                                           EmpathyCapabilities capabilities)
289 {
290   EmpathyTpCallPriv *priv = GET_PRIV (call);
291   DBusGProxy *streamed_iface;
292   GArray *stream_types;
293   guint handle;
294   guint stream_type;
295   GError *error = NULL;
296
297   empathy_debug (DEBUG_DOMAIN, "Requesting new stream for capabilities %d",
298       capabilities);
299
300   streamed_iface = tp_chan_get_interface (priv->channel,
301       TELEPATHY_CHAN_IFACE_STREAMED_QUARK);
302   stream_types = g_array_new (FALSE, FALSE, sizeof (guint));
303   handle = empathy_contact_get_handle (priv->contact);
304
305   if (capabilities & EMPATHY_CAPABILITIES_AUDIO)
306     {
307       stream_type = TP_MEDIA_STREAM_TYPE_AUDIO;
308       g_array_append_val (stream_types, stream_type);
309     }
310   if (capabilities & EMPATHY_CAPABILITIES_VIDEO)
311     {
312       stream_type = TP_MEDIA_STREAM_TYPE_VIDEO;
313       g_array_append_val (stream_types, stream_type);
314     }
315
316   if (!tp_chan_type_streamed_media_request_streams (streamed_iface, handle,
317         stream_types, NULL, &error))
318     {
319       empathy_debug (DEBUG_DOMAIN, "Couldn't request new stream: %s",
320           error->message);
321       g_clear_error (&error);
322     }
323
324   g_array_free (stream_types, TRUE);
325 }
326
327 static void
328 tp_call_request_streams_capabilities_cb (EmpathyContact *contact,
329                                          GParamSpec *property,
330                                          gpointer user_data)
331 {
332   EmpathyTpCall *call = EMPATHY_TP_CALL (user_data);
333
334   g_signal_handlers_disconnect_by_func (contact,
335       tp_call_request_streams_capabilities_cb,
336       user_data);
337
338   tp_call_request_streams_for_capabilities (call,
339      empathy_contact_get_capabilities (contact));
340 }
341
342 static void
343 tp_call_request_streams (EmpathyTpCall *call)
344 {
345   EmpathyTpCallPriv *priv = GET_PRIV (call);
346   EmpathyCapabilities capabilities;
347   DBusGProxy *capabilities_iface;
348
349   empathy_debug (DEBUG_DOMAIN,
350       "Requesting appropriate audio/video streams from contact");
351
352
353   /* FIXME: SIP don't have capabilities interface but we know it supports
354    *        only audio and not video. */
355   capabilities_iface = tp_conn_get_interface (priv->connection,
356       TP_IFACE_QUARK_CONNECTION_INTERFACE_CAPABILITIES);
357   if (!capabilities_iface)
358     {
359       capabilities = EMPATHY_CAPABILITIES_AUDIO;
360     }
361   else
362     {
363       capabilities = empathy_contact_get_capabilities (priv->contact);
364       if (capabilities == EMPATHY_CAPABILITIES_UNKNOWN)
365         {
366           g_signal_connect (priv->contact, "notify::capabilities",
367               G_CALLBACK (tp_call_request_streams_capabilities_cb), call);
368           return;
369         }
370     }
371
372   tp_call_request_streams_for_capabilities (call, capabilities);
373 }
374
375 static void
376 tp_call_is_ready (EmpathyTpCall *call)
377 {
378   EmpathyTpCallPriv *priv = GET_PRIV (call);
379   EmpathyContact *self_contact;
380   GList *members;
381   GList *local_pendings;
382   GList *remote_pendings;
383
384   if (priv->status > EMPATHY_TP_CALL_STATUS_READYING)
385     return;
386
387   members = empathy_tp_group_get_members (priv->group);
388   if (!members)
389     return;
390
391   self_contact = empathy_tp_group_get_self_contact (priv->group);
392   local_pendings = empathy_tp_group_get_local_pendings (priv->group);
393   remote_pendings = empathy_tp_group_get_remote_pendings (priv->group);
394
395   if (local_pendings &&
396       empathy_contact_equal (EMPATHY_CONTACT (((EmpathyPendingInfo *)
397             local_pendings->data)->member), self_contact))
398     {
399       empathy_debug (DEBUG_DOMAIN,
400           "Incoming call is ready - %p",
401           ((EmpathyPendingInfo *) local_pendings->data)->member);
402       priv->is_incoming = TRUE;
403       priv->contact = g_object_ref (members->data);
404     }
405   else if (remote_pendings &&
406       empathy_contact_equal (EMPATHY_CONTACT (members->data), self_contact))
407     {
408       empathy_debug (DEBUG_DOMAIN,
409           "Outgoing call is ready - %p", remote_pendings->data);
410       priv->is_incoming = FALSE;
411       priv->contact = g_object_ref (remote_pendings->data);
412       tp_call_request_streams (call);
413     }
414
415   g_object_unref (self_contact);
416   g_list_foreach (members, (GFunc) g_object_unref, NULL);
417   g_list_free (members);
418   g_list_foreach (local_pendings, (GFunc) empathy_pending_info_free, NULL);
419   g_list_free (local_pendings);
420   g_list_foreach (remote_pendings, (GFunc) g_object_unref, NULL);
421   g_list_free (remote_pendings);
422
423   if (priv->contact)
424     {
425       priv->status = EMPATHY_TP_CALL_STATUS_PENDING;
426       g_signal_emit (call, signals[STATUS_CHANGED_SIGNAL], 0);
427     }
428 }
429
430 static void
431 tp_call_member_added_cb (EmpathyTpGroup *group,
432                          EmpathyContact *contact,
433                          EmpathyContact *actor,
434                          guint reason,
435                          const gchar *message,
436                          EmpathyTpCall *call)
437 {
438   EmpathyTpCallPriv *priv = GET_PRIV (call);
439
440   empathy_debug (DEBUG_DOMAIN, "New member added callback %p", contact);
441   tp_call_is_ready (call);
442
443   if (priv->status == EMPATHY_TP_CALL_STATUS_PENDING)
444     {
445       if ((priv->is_incoming &&
446             !empathy_contact_equal (contact, priv->contact))
447           || (!priv->is_incoming &&
448             empathy_contact_equal (contact, priv->contact)))
449         {
450           priv->status = EMPATHY_TP_CALL_STATUS_ACCEPTED;
451           g_signal_emit (call, signals[STATUS_CHANGED_SIGNAL], 0);
452         }
453     }
454 }
455
456 static void
457 tp_call_local_pending_cb (EmpathyTpGroup *group,
458                           EmpathyContact *contact,
459                           EmpathyContact *actor,
460                           guint reason,
461                           const gchar *message,
462                           EmpathyTpCall *call)
463 {
464   empathy_debug (DEBUG_DOMAIN, "New local pending added callback %p", contact);
465   tp_call_is_ready (call);
466 }
467
468 static void
469 tp_call_remote_pending_cb (EmpathyTpGroup *group,
470                            EmpathyContact *contact,
471                            EmpathyContact *actor,
472                            guint reason,
473                            const gchar *message,
474                            EmpathyTpCall *call)
475 {
476   empathy_debug (DEBUG_DOMAIN, "New remote pending added callback %p", contact);
477   tp_call_is_ready (call);
478 }
479
480 static void
481 tp_call_async_cb (TpProxy *proxy,
482                   const GError *error,
483                   gpointer user_data,
484                   GObject *weak_object)
485 {
486   if (error)
487     {
488       empathy_debug (DEBUG_DOMAIN, "Error %s: %s",
489           user_data, error->message);
490     }
491 }
492
493 static void
494 tp_call_start_stream_engine (EmpathyTpCall *call)
495 {
496   EmpathyTpCallPriv *priv = GET_PRIV (call);
497
498   empathy_debug (DEBUG_DOMAIN, "Revving up the stream engine");
499
500   priv->stream_engine = g_object_new (TP_TYPE_PROXY,
501       "bus-name", STREAM_ENGINE_BUS_NAME,
502       "dbus-connection", tp_get_bus (),
503       "object-path", STREAM_ENGINE_OBJECT_PATH);
504   tp_proxy_add_interface_by_id (priv->stream_engine,
505       EMP_IFACE_QUARK_STREAM_ENGINE);
506   tp_proxy_add_interface_by_id (priv->stream_engine,
507       EMP_IFACE_QUARK_CHANNEL_HANDLER);
508
509   emp_cli_channel_handler_call_handle_channel (priv->stream_engine, -1,
510         dbus_g_proxy_get_bus_name (DBUS_G_PROXY (priv->connection)),
511         dbus_g_proxy_get_path (DBUS_G_PROXY (priv->connection)),
512         priv->channel->type,
513         dbus_g_proxy_get_path (DBUS_G_PROXY (priv->channel)),
514         priv->channel->handle_type, priv->channel->handle,
515         tp_call_async_cb,
516         "calling handle channel", NULL,
517         G_OBJECT (call));
518 }
519
520 static GObject *
521 tp_call_constructor (GType type,
522                      guint n_construct_params,
523                      GObjectConstructParam *construct_params)
524 {
525   GObject *object;
526   EmpathyTpCall *call;
527   EmpathyTpCallPriv *priv;
528   DBusGProxy *streamed_iface;
529   MissionControl *mc;
530   McAccount *account;
531
532   object = G_OBJECT_CLASS (empathy_tp_call_parent_class)->constructor (type,
533       n_construct_params, construct_params);
534
535   call = EMPATHY_TP_CALL (object);
536   priv = GET_PRIV (call);
537
538   dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->channel), "Closed",
539      G_CALLBACK (tp_call_channel_closed_cb), (gpointer) call, NULL);
540
541   streamed_iface = tp_chan_get_interface (priv->channel,
542       TELEPATHY_CHAN_IFACE_STREAMED_QUARK);
543   dbus_g_proxy_connect_signal (streamed_iface, "StreamStateChanged",
544       G_CALLBACK (tp_call_stream_state_changed_cb),
545       (gpointer) call, NULL);
546   dbus_g_proxy_connect_signal (streamed_iface, "StreamDirectionChanged",
547       G_CALLBACK (tp_call_stream_direction_changed_cb),
548       (gpointer) call, NULL);
549   dbus_g_proxy_connect_signal (streamed_iface, "StreamAdded",
550       G_CALLBACK (tp_call_stream_added_cb), (gpointer) call, NULL);
551   dbus_g_proxy_connect_signal (streamed_iface, "StreamRemoved",
552       G_CALLBACK (tp_call_stream_removed_cb), (gpointer) call, NULL);
553
554   mc = empathy_mission_control_new ();
555   account = mission_control_get_account_for_connection (mc, priv->connection,
556       NULL);
557   priv->group = empathy_tp_group_new (account, priv->channel);
558   g_object_unref (mc);
559
560   g_signal_connect (G_OBJECT (priv->group), "member-added",
561       G_CALLBACK (tp_call_member_added_cb), (gpointer) call);
562   g_signal_connect (G_OBJECT (priv->group), "local-pending",
563       G_CALLBACK (tp_call_local_pending_cb), (gpointer) call);
564   g_signal_connect (G_OBJECT (priv->group), "remote-pending",
565       G_CALLBACK (tp_call_remote_pending_cb), (gpointer) call);
566
567   tp_call_start_stream_engine (call);
568   /* FIXME: unnecessary for outgoing? */
569   tp_call_identify_streams (call);
570
571   return object;
572 }
573
574 static void 
575 tp_call_finalize (GObject *object)
576 {
577   EmpathyTpCallPriv *priv = GET_PRIV (object);
578
579   empathy_debug (DEBUG_DOMAIN, "Finalizing: %p", object);
580
581   g_slice_free (EmpathyTpCallStream, priv->audio);
582   g_slice_free (EmpathyTpCallStream, priv->video);
583   g_object_unref (priv->group);
584
585   if (priv->connection != NULL)
586     g_object_unref (priv->connection);
587
588   if (priv->channel != NULL)
589     g_object_unref (priv->channel);
590
591   if (priv->contact)
592     {
593       g_object_unref (priv->contact);
594     }
595
596   (G_OBJECT_CLASS (empathy_tp_call_parent_class)->finalize) (object);
597 }
598
599 static void 
600 tp_call_set_property (GObject *object,
601                       guint prop_id,
602                       const GValue *value,
603                       GParamSpec *pspec)
604 {
605   EmpathyTpCallPriv *priv = GET_PRIV (object);
606
607   switch (prop_id)
608     {
609     case PROP_CONNECTION:
610       priv->connection = g_value_dup_object (value);
611       break;
612     case PROP_CHANNEL:
613       priv->channel = g_value_dup_object (value);
614       break;
615     case PROP_CONTACT:
616       /* FIXME should this one be writable in the first place ? */
617       g_assert (priv->contact == NULL);
618       priv->contact = g_value_dup_object (value);
619       break;
620     case PROP_IS_INCOMING:
621       priv->is_incoming = g_value_get_boolean (value);
622       break;
623     case PROP_STATUS:
624       priv->status = g_value_get_uint (value);
625       break;
626     case PROP_AUDIO_STREAM:
627       priv->audio = g_value_get_pointer (value);
628       break;
629     case PROP_VIDEO_STREAM:
630       priv->video = g_value_get_pointer (value);
631       break;
632     default:
633       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
634       break;
635   }
636 }
637
638
639 static void
640 tp_call_get_property (GObject *object,
641                       guint prop_id,
642                       GValue *value,
643                       GParamSpec *pspec)
644 {
645   EmpathyTpCallPriv *priv = GET_PRIV (object);
646
647   switch (prop_id)
648     {
649     case PROP_CONNECTION:
650       g_value_set_object (value, priv->connection);
651       break;
652     case PROP_CHANNEL:
653       g_value_set_object (value, priv->channel);
654       break;
655     case PROP_CONTACT:
656       g_value_set_object (value, priv->contact);
657       break;
658     case PROP_IS_INCOMING:
659       g_value_set_boolean (value, priv->is_incoming);
660       break;
661     case PROP_STATUS:
662       g_value_set_uint (value, priv->status);
663       break;
664     case PROP_AUDIO_STREAM:
665       g_value_set_pointer (value, priv->audio);
666       break;
667     case PROP_VIDEO_STREAM:
668       g_value_set_pointer (value, priv->video);
669       break;
670     default:
671       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
672       break;
673   }
674 }
675
676 static void
677 empathy_tp_call_class_init (EmpathyTpCallClass *klass)
678 {
679   GObjectClass *object_class = G_OBJECT_CLASS (klass);
680
681   object_class->constructor = tp_call_constructor;
682   object_class->finalize = tp_call_finalize;
683   object_class->set_property = tp_call_set_property;
684   object_class->get_property = tp_call_get_property;
685
686   g_type_class_add_private (klass, sizeof (EmpathyTpCallPriv));
687
688   signals[STATUS_CHANGED_SIGNAL] =
689       g_signal_new ("status-changed", G_TYPE_FROM_CLASS (klass),
690       G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID,
691       G_TYPE_NONE, 0);
692   signals[RECEIVING_VIDEO_SIGNAL] =
693       g_signal_new ("receiving-video", G_TYPE_FROM_CLASS (klass),
694       G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN,
695       G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
696   signals[SENDING_VIDEO_SIGNAL] =
697       g_signal_new ("sending-video", G_TYPE_FROM_CLASS (klass),
698       G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN,
699       G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
700
701   g_object_class_install_property (object_class, PROP_CONNECTION,
702       g_param_spec_object ("connection", "connection", "connection",
703       TELEPATHY_CONN_TYPE,
704       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
705       G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
706   g_object_class_install_property (object_class, PROP_CHANNEL,
707       g_param_spec_object ("channel", "channel", "channel",
708       TELEPATHY_CHAN_TYPE,
709       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
710       G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
711   g_object_class_install_property (object_class, PROP_CONTACT,
712       g_param_spec_object ("contact", "Call contact", "Call contact",
713       EMPATHY_TYPE_CONTACT,
714       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
715   g_object_class_install_property (object_class, PROP_IS_INCOMING,
716       g_param_spec_boolean ("is-incoming", "Is media stream incoming",
717       "Is media stream incoming", FALSE, G_PARAM_READABLE |
718       G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
719   g_object_class_install_property (object_class, PROP_STATUS,
720       g_param_spec_uint ("status", "Call status",
721       "Call status", 0, 255, 0, G_PARAM_READABLE | G_PARAM_STATIC_NICK |
722       G_PARAM_STATIC_BLURB));
723   g_object_class_install_property (object_class, PROP_AUDIO_STREAM,
724       g_param_spec_pointer ("audio-stream", "Audio stream data",
725       "Audio stream data",
726       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
727   g_object_class_install_property (object_class, PROP_VIDEO_STREAM,
728       g_param_spec_pointer ("video-stream", "Video stream data",
729       "Video stream data",
730       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
731 }
732
733 static void
734 empathy_tp_call_init (EmpathyTpCall *call)
735 {
736   EmpathyTpCallPriv *priv = GET_PRIV (call);
737
738   priv->status = EMPATHY_TP_CALL_STATUS_READYING;
739   priv->contact = NULL;
740   priv->audio = g_slice_new0 (EmpathyTpCallStream);
741   priv->video = g_slice_new0 (EmpathyTpCallStream);
742   priv->audio->exists = FALSE;
743   priv->video->exists = FALSE;
744 }
745
746 EmpathyTpCall *
747 empathy_tp_call_new (TpConn *connection, TpChan *channel)
748 {
749   return g_object_new (EMPATHY_TYPE_TP_CALL,
750       "connection", connection,
751       "channel", channel,
752       NULL);
753 }
754
755 void
756 empathy_tp_call_accept_incoming_call (EmpathyTpCall *call)
757 {
758   EmpathyTpCallPriv *priv = GET_PRIV (call);
759   GList *local_pendings;
760
761   empathy_debug (DEBUG_DOMAIN, "Accepting incoming call");
762
763   local_pendings = empathy_tp_group_get_local_pendings (priv->group);
764
765   empathy_tp_group_add_member (priv->group, EMPATHY_CONTACT
766       (((EmpathyPendingInfo *) local_pendings->data)->member), NULL);
767
768   g_list_foreach (local_pendings, (GFunc) empathy_pending_info_free, NULL);
769   g_list_free (local_pendings);
770 }
771
772 void
773 empathy_tp_call_request_video_stream_direction (EmpathyTpCall *call,
774                                                 gboolean is_sending)
775 {
776   EmpathyTpCallPriv *priv = GET_PRIV (call);
777   DBusGProxy *streamed_iface;
778   guint new_direction;
779   GError *error = NULL;
780
781   empathy_debug (DEBUG_DOMAIN,
782       "Requesting video stream direction - is_sending: %d", is_sending);
783
784   if (!priv->video->exists)
785     {
786       tp_call_request_streams_for_capabilities (call, EMPATHY_CAPABILITIES_VIDEO);
787       return;
788     }
789
790   streamed_iface = tp_chan_get_interface (priv->channel,
791       TELEPATHY_CHAN_IFACE_STREAMED_QUARK);
792
793   if (is_sending)
794     {
795       new_direction = priv->video->direction | TP_MEDIA_STREAM_DIRECTION_SEND;
796     }
797   else
798     {
799       new_direction = priv->video->direction & ~TP_MEDIA_STREAM_DIRECTION_SEND;
800     }
801
802   if (!tp_chan_type_streamed_media_request_stream_direction (streamed_iface,
803         priv->video->id, new_direction, &error))
804     {
805       empathy_debug (DEBUG_DOMAIN,
806           "Couldn't request video stream direction: %s", error->message);
807       g_clear_error (&error);
808     }
809 }
810
811 void
812 empathy_tp_call_close_channel (EmpathyTpCall *call)
813 {
814   EmpathyTpCallPriv *priv = GET_PRIV (call);
815   GError *error = NULL;
816
817   empathy_debug (DEBUG_DOMAIN, "Closing channel");
818
819   if (!tp_chan_close (DBUS_G_PROXY (priv->channel), &error))
820     {
821       empathy_debug (DEBUG_DOMAIN, "Error closing channel: %s",
822           error ? error->message : "No error given");
823       g_clear_error (&error);
824     }
825 }
826
827 void
828 empathy_tp_call_add_preview_video (EmpathyTpCall *call,
829                                    guint preview_video_socket_id)
830 {
831   EmpathyTpCallPriv *priv = GET_PRIV (call);
832
833   empathy_debug (DEBUG_DOMAIN, "Adding preview video");
834
835   emp_cli_stream_engine_call_add_preview_window (priv->stream_engine, -1,
836       preview_video_socket_id,
837       tp_call_async_cb,
838       "adding preview window", NULL,
839       G_OBJECT (call));
840 }
841
842 void
843 empathy_tp_call_remove_preview_video (EmpathyTpCall *call,
844                                       guint preview_video_socket_id)
845 {
846   EmpathyTpCallPriv *priv = GET_PRIV (call);
847
848   empathy_debug (DEBUG_DOMAIN, "Removing preview video");
849
850   emp_cli_stream_engine_call_remove_preview_window (priv->stream_engine, -1,
851       preview_video_socket_id,
852       tp_call_async_cb,
853       "removing preview window", NULL,
854       G_OBJECT (call));
855 }
856
857 void
858 empathy_tp_call_add_output_video (EmpathyTpCall *call,
859                                   guint output_video_socket_id)
860 {
861   EmpathyTpCallPriv *priv = GET_PRIV (call);
862
863   empathy_debug (DEBUG_DOMAIN, "Adding output video - socket: %d",
864       output_video_socket_id);
865
866   emp_cli_stream_engine_call_set_output_window (priv->stream_engine, -1,
867       dbus_g_proxy_get_path (DBUS_G_PROXY (priv->channel)),
868       priv->video->id, output_video_socket_id,
869       tp_call_async_cb,
870       "setting output window", NULL,
871       G_OBJECT (call));
872 }
873
874 void
875 empathy_tp_call_set_output_volume (EmpathyTpCall *call,
876                                    guint volume)
877 {
878   EmpathyTpCallPriv *priv = GET_PRIV (call);
879
880   if (priv->status == EMPATHY_TP_CALL_STATUS_CLOSED)
881     return;
882
883   empathy_debug (DEBUG_DOMAIN, "Setting output volume: %d", volume);
884
885   emp_cli_stream_engine_call_set_output_volume (priv->stream_engine, -1,
886       dbus_g_proxy_get_path (DBUS_G_PROXY (priv->channel)),
887       priv->audio->id, volume,
888       tp_call_async_cb,
889       "setting output volume", NULL,
890       G_OBJECT (call));
891 }
892
893 void
894 empathy_tp_call_mute_output (EmpathyTpCall *call,
895                              gboolean is_muted)
896 {
897   EmpathyTpCallPriv *priv = GET_PRIV (call);
898
899   if (priv->status == EMPATHY_TP_CALL_STATUS_CLOSED)
900     return;
901
902   empathy_debug (DEBUG_DOMAIN, "Setting output mute: %d", is_muted);
903
904   emp_cli_stream_engine_call_mute_output (priv->stream_engine, -1,
905       dbus_g_proxy_get_path (DBUS_G_PROXY (priv->channel)),
906       priv->audio->id, is_muted,
907       tp_call_async_cb,
908       "muting output", NULL,
909       G_OBJECT (call));
910 }
911
912 void
913 empathy_tp_call_mute_input (EmpathyTpCall *call,
914                             gboolean is_muted)
915 {
916   EmpathyTpCallPriv *priv = GET_PRIV (call);
917
918   if (priv->status == EMPATHY_TP_CALL_STATUS_CLOSED)
919     return;
920
921   empathy_debug (DEBUG_DOMAIN, "Setting input mute: %d", is_muted);
922
923   emp_cli_stream_engine_call_mute_input (priv->stream_engine, -1,
924       dbus_g_proxy_get_path (DBUS_G_PROXY (priv->channel)),
925       priv->audio->id, is_muted,
926       tp_call_async_cb,
927       "muting input", NULL,
928       G_OBJECT (call));
929 }
930