libempathy/empathy-tp-call.c

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