libempathy/empathy-tp-streamed-media.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 #include <telepathy-glib/util.h>
  29
  30 #include "empathy-tp-streamed-media.h"
  31 #include "empathy-tp-contact-factory.h"
  32 #include "empathy-utils.h"
  33
  34 #define DEBUG_FLAG EMPATHY_DEBUG_VOIP
  35 #include "empathy-debug.h"
  36
  37 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyTpStreamedMedia)
  38 typedef struct
  39 {
  40   gboolean dispose_has_run;
  41   TpAccount *account;
  42   TpChannel *channel;
  43   EmpathyContact *contact;
  44   gboolean is_incoming;
  45   guint status;
  46
  47   EmpathyTpStreamedMediaStream *audio;
  48   EmpathyTpStreamedMediaStream *video;
  49 } EmpathyTpStreamedMediaPriv;
  50
  51 /* signal enum */
  52 enum {
  53   AUDIO_STREAM_ERROR,
  54   VIDEO_STREAM_ERROR,
  55   LAST_SIGNAL
  56 };
  57
  58 static guint signals[LAST_SIGNAL] = {0};
  59
  60 enum
  61 {
  62   PROP_0,
  63   PROP_ACCOUNT,
  64   PROP_CHANNEL,
  65   PROP_CONTACT,
  66   PROP_STATUS,
  67   PROP_AUDIO_STREAM,
  68   PROP_VIDEO_STREAM
  69 };
  70
  71 G_DEFINE_TYPE (EmpathyTpStreamedMedia, empathy_tp_streamed_media, G_TYPE_OBJECT)
  72
  73 static void
  74 tp_streamed_media_add_stream (EmpathyTpStreamedMedia *call,
  75                     guint stream_id,
  76                     guint contact_handle,
  77                     guint stream_type,
  78                     guint stream_state,
  79                     guint stream_direction)
  80 {
  81   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
  82
  83   switch (stream_type)
  84     {
  85       case TP_MEDIA_STREAM_TYPE_AUDIO:
  86         DEBUG ("Audio stream - id: %d, state: %d, direction: %d",
  87             stream_id, stream_state, stream_direction);
  88         priv->audio->exists = TRUE;
  89         priv->audio->id = stream_id;
  90         priv->audio->state = stream_state;
  91         priv->audio->direction = stream_direction;
  92         g_object_notify (G_OBJECT (call), "audio-stream");
  93         break;
  94       case TP_MEDIA_STREAM_TYPE_VIDEO:
  95         DEBUG ("Video stream - id: %d, state: %d, direction: %d",
  96             stream_id, stream_state, stream_direction);
  97         priv->video->exists = TRUE;
  98         priv->video->id = stream_id;
  99         priv->video->state = stream_state;
 100         priv->video->direction = stream_direction;
 101         g_object_notify (G_OBJECT (call), "video-stream");
 102         break;
 103       default:
 104         DEBUG ("Unknown stream type: %d", stream_type);
 105     }
 106 }
 107
 108 static void
 109 tp_streamed_media_stream_added_cb (TpChannel *channel,
 110                          guint stream_id,
 111                          guint contact_handle,
 112                          guint stream_type,
 113                          gpointer user_data,
 114                          GObject *call)
 115 {
 116   DEBUG ("Stream added - stream id: %d, contact handle: %d, stream type: %d",
 117       stream_id, contact_handle, stream_type);
 118
 119   tp_streamed_media_add_stream (EMPATHY_TP_STREAMED_MEDIA (call), stream_id, contact_handle,
 120       stream_type, TP_MEDIA_STREAM_STATE_DISCONNECTED,
 121       TP_MEDIA_STREAM_DIRECTION_NONE);
 122 }
 123
 124 static void
 125 tp_streamed_media_stream_removed_cb (TpChannel *channel,
 126                            guint stream_id,
 127                            gpointer user_data,
 128                            GObject *call)
 129 {
 130   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 131
 132   DEBUG ("Stream removed - stream id: %d", stream_id);
 133
 134   if (stream_id == priv->audio->id)
 135     {
 136       priv->audio->exists = FALSE;
 137       g_object_notify (call, "audio-stream");
 138     }
 139   else if (stream_id == priv->video->id)
 140     {
 141       priv->video->exists = FALSE;
 142       g_object_notify (call, "video-stream");
 143     }
 144 }
 145
 146 static void
 147 tp_streamed_media_stream_state_changed_cb (TpChannel *proxy,
 148                                  guint stream_id,
 149                                  guint stream_state,
 150                                  gpointer user_data,
 151                                  GObject *call)
 152 {
 153   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 154
 155   DEBUG ("Stream state changed - stream id: %d, state state: %d",
 156       stream_id, stream_state);
 157
 158   if (stream_id == priv->audio->id)
 159     {
 160       priv->audio->state = stream_state;
 161       g_object_notify (call, "audio-stream");
 162     }
 163   else if (stream_id == priv->video->id)
 164     {
 165       priv->video->state = stream_state;
 166       g_object_notify (call, "video-stream");
 167     }
 168 }
 169
 170 static void
 171 tp_streamed_media_stream_direction_changed_cb (TpChannel *channel,
 172                                      guint stream_id,
 173                                      guint stream_direction,
 174                                      guint pending_flags,
 175                                      gpointer user_data,
 176                                      GObject *call)
 177 {
 178   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 179
 180   DEBUG ("Stream direction changed - stream: %d, direction: %d",
 181       stream_id, stream_direction);
 182
 183   if (stream_id == priv->audio->id)
 184     {
 185       priv->audio->direction = stream_direction;
 186       g_object_notify (call, "audio-stream");
 187     }
 188   else if (stream_id == priv->video->id)
 189     {
 190       priv->video->direction = stream_direction;
 191       g_object_notify (call, "video-stream");
 192     }
 193 }
 194
 195 static void
 196 tp_streamed_media_request_streams_cb (TpChannel *channel,
 197                             const GPtrArray *streams,
 198                             const GError *error,
 199                             gpointer user_data,
 200                             GObject *call)
 201 {
 202   guint i;
 203
 204   if (error)
 205     {
 206       DEBUG ("Error requesting streams: %s", error->message);
 207       return;
 208     }
 209
 210   for (i = 0; i < streams->len; i++)
 211     {
 212       GValueArray *values;
 213       guint stream_id;
 214       guint contact_handle;
 215       guint stream_type;
 216       guint stream_state;
 217       guint stream_direction;
 218
 219       values = g_ptr_array_index (streams, i);
 220       stream_id = g_value_get_uint (g_value_array_get_nth (values, 0));
 221       contact_handle = g_value_get_uint (g_value_array_get_nth (values, 1));
 222       stream_type = g_value_get_uint (g_value_array_get_nth (values, 2));
 223       stream_state = g_value_get_uint (g_value_array_get_nth (values, 3));
 224       stream_direction = g_value_get_uint (g_value_array_get_nth (values, 4));
 225
 226       tp_streamed_media_add_stream (EMPATHY_TP_STREAMED_MEDIA (call), stream_id, contact_handle,
 227           stream_type, stream_state, stream_direction);
 228   }
 229 }
 230
 231 static void
 232 tp_streamed_media_request_streams_for_capabilities (EmpathyTpStreamedMedia *call,
 233                                           EmpathyCapabilities capabilities)
 234 {
 235   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 236   GArray *stream_types;
 237   guint handle;
 238   guint stream_type;
 239
 240   if (capabilities == EMPATHY_CAPABILITIES_UNKNOWN)
 241       capabilities = EMPATHY_CAPABILITIES_AUDIO | EMPATHY_CAPABILITIES_VIDEO;
 242
 243   DEBUG ("Requesting new stream for capabilities %d",
 244       capabilities);
 245
 246   stream_types = g_array_new (FALSE, FALSE, sizeof (guint));
 247   handle = empathy_contact_get_handle (priv->contact);
 248
 249   if (capabilities & EMPATHY_CAPABILITIES_AUDIO)
 250     {
 251       stream_type = TP_MEDIA_STREAM_TYPE_AUDIO;
 252       g_array_append_val (stream_types, stream_type);
 253     }
 254   if (capabilities & EMPATHY_CAPABILITIES_VIDEO)
 255     {
 256       stream_type = TP_MEDIA_STREAM_TYPE_VIDEO;
 257       g_array_append_val (stream_types, stream_type);
 258     }
 259
 260   tp_cli_channel_type_streamed_media_call_request_streams (priv->channel, -1,
 261       handle, stream_types, tp_streamed_media_request_streams_cb, NULL, NULL,
 262       G_OBJECT (call));
 263
 264   g_array_unref (stream_types);
 265 }
 266
 267 static void
 268 tp_streamed_media_got_contact_cb (TpConnection            *connection,
 269                         EmpathyContact          *contact,
 270                         const GError            *error,
 271                         gpointer                 user_data,
 272                         GObject                 *call)
 273 {
 274   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 275
 276   if (error)
 277     {
 278       DEBUG ("Error: %s", error->message);
 279       return;
 280     }
 281
 282   priv->contact = g_object_ref (contact);
 283
 284   if (priv->status < EMPATHY_TP_STREAMED_MEDIA_STATUS_PENDING)
 285     {
 286       priv->status = EMPATHY_TP_STREAMED_MEDIA_STATUS_PENDING;
 287       g_object_notify (G_OBJECT (call), "status");
 288     }
 289
 290   g_object_notify (G_OBJECT (call), "contact");
 291 }
 292
 293 static void
 294 tp_streamed_media_update_status (EmpathyTpStreamedMedia *call)
 295 {
 296   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 297   TpHandle self_handle;
 298   const TpIntSet *set;
 299   TpIntSetIter iter;
 300
 301   g_object_ref (call);
 302
 303   self_handle = tp_channel_group_get_self_handle (priv->channel);
 304   set = tp_channel_group_get_members (priv->channel);
 305   tp_intset_iter_init (&iter, set);
 306   while (tp_intset_iter_next (&iter))
 307     {
 308       if (priv->status == EMPATHY_TP_STREAMED_MEDIA_STATUS_PENDING &&
 309           ((priv->is_incoming && iter.element == self_handle) ||
 310            (!priv->is_incoming && iter.element != self_handle)))
 311         {
 312           priv->status = EMPATHY_TP_STREAMED_MEDIA_STATUS_ACCEPTED;
 313           g_object_notify (G_OBJECT (call), "status");
 314         }
 315     }
 316
 317   g_object_unref (call);
 318 }
 319
 320 static void
 321 tp_streamed_media_channel_invalidated_cb (TpChannel     *channel,
 322                                 GQuark         domain,
 323                                 gint           code,
 324                                 gchar         *message,
 325                                 EmpathyTpStreamedMedia *call)
 326 {
 327   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 328
 329   DEBUG ("Channel invalidated: %s", message);
 330   priv->status = EMPATHY_TP_STREAMED_MEDIA_STATUS_CLOSED;
 331   g_object_notify (G_OBJECT (call), "status");
 332 }
 333
 334 static void
 335 tp_streamed_media_async_cb (TpProxy *proxy,
 336                   const GError *error,
 337                   gpointer user_data,
 338                   GObject *call)
 339 {
 340   if (error)
 341       DEBUG ("Error %s: %s", (gchar *) user_data, error->message);
 342 }
 343
 344 static void
 345 tp_streamed_media_stream_error_cb (TpChannel *channel,
 346     guint stream_id,
 347     guint error_code,
 348     const gchar *msg,
 349     gpointer user_data,
 350     GObject *call)
 351 {
 352   EmpathyTpStreamedMedia *self = EMPATHY_TP_STREAMED_MEDIA (call);
 353   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (self);
 354
 355   DEBUG ("Stream error on stream %u: %s (code: %u)", stream_id, msg,
 356       error_code);
 357
 358   if (priv->audio->id == stream_id)
 359     {
 360       g_signal_emit (call, signals[AUDIO_STREAM_ERROR], 0, error_code, msg);
 361     }
 362   else if (priv->video->id == stream_id)
 363     {
 364       g_signal_emit (call, signals[VIDEO_STREAM_ERROR], 0, error_code, msg);
 365     }
 366   else
 367     {
 368       DEBUG ("Unknown stream id: %u", stream_id);
 369     }
 370 }
 371
 372 static GObject *
 373 tp_streamed_media_constructor (GType type,
 374                      guint n_construct_params,
 375                      GObjectConstructParam *construct_params)
 376 {
 377   GObject *object;
 378   EmpathyTpStreamedMedia *call;
 379   EmpathyTpStreamedMediaPriv *priv;
 380
 381   object = G_OBJECT_CLASS (empathy_tp_streamed_media_parent_class)->constructor (type,
 382       n_construct_params, construct_params);
 383
 384   call = EMPATHY_TP_STREAMED_MEDIA (object);
 385   priv = GET_PRIV (call);
 386
 387   /* Setup streamed media channel */
 388   g_signal_connect (priv->channel, "invalidated",
 389       G_CALLBACK (tp_streamed_media_channel_invalidated_cb), call);
 390   tp_cli_channel_type_streamed_media_connect_to_stream_added (priv->channel,
 391       tp_streamed_media_stream_added_cb, NULL, NULL, G_OBJECT (call), NULL);
 392   tp_cli_channel_type_streamed_media_connect_to_stream_removed (priv->channel,
 393       tp_streamed_media_stream_removed_cb, NULL, NULL, G_OBJECT (call), NULL);
 394   tp_cli_channel_type_streamed_media_connect_to_stream_state_changed (priv->channel,
 395       tp_streamed_media_stream_state_changed_cb, NULL, NULL, G_OBJECT (call), NULL);
 396   tp_cli_channel_type_streamed_media_connect_to_stream_direction_changed (priv->channel,
 397       tp_streamed_media_stream_direction_changed_cb, NULL, NULL, G_OBJECT (call), NULL);
 398   tp_cli_channel_type_streamed_media_connect_to_stream_error (priv->channel,
 399       tp_streamed_media_stream_error_cb, NULL, NULL, G_OBJECT (call), NULL);
 400   tp_cli_channel_type_streamed_media_call_list_streams (priv->channel, -1,
 401       tp_streamed_media_request_streams_cb, NULL, NULL, G_OBJECT (call));
 402
 403   /* Is the call incoming? */
 404   priv->is_incoming = !tp_channel_get_requested (priv->channel);
 405
 406   /* Get the remote contact */
 407   empathy_tp_contact_factory_get_from_handle (
 408       tp_channel_borrow_connection (priv->channel),
 409       tp_channel_get_handle (priv->channel, NULL), tp_streamed_media_got_contact_cb,
 410       NULL, NULL, object);
 411
 412   /* Update status when members changes */
 413   tp_streamed_media_update_status (call);
 414   tp_g_signal_connect_object (priv->channel, "group-members-changed",
 415       G_CALLBACK (tp_streamed_media_update_status), call, G_CONNECT_SWAPPED);
 416
 417   return object;
 418 }
 419 static void
 420 tp_streamed_media_dispose (GObject *object)
 421 {
 422   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (object);
 423
 424   DEBUG ("Disposing: %p, %d", object, priv->dispose_has_run);
 425
 426   if (priv->dispose_has_run)
 427     return;
 428
 429   priv->dispose_has_run = TRUE;
 430
 431   if (priv->channel != NULL)
 432     {
 433       g_signal_handlers_disconnect_by_func (priv->channel,
 434         tp_streamed_media_channel_invalidated_cb, object);
 435
 436       g_object_unref (priv->channel);
 437       priv->channel = NULL;
 438     }
 439
 440   if (priv->contact != NULL)
 441       g_object_unref (priv->contact);
 442
 443   tp_clear_object (&priv->account);
 444
 445   if (G_OBJECT_CLASS (empathy_tp_streamed_media_parent_class)->dispose)
 446     G_OBJECT_CLASS (empathy_tp_streamed_media_parent_class)->dispose (object);
 447 }
 448
 449 static void
 450 tp_streamed_media_finalize (GObject *object)
 451 {
 452   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (object);
 453
 454   DEBUG ("Finalizing: %p", object);
 455
 456   g_slice_free (EmpathyTpStreamedMediaStream, priv->audio);
 457   g_slice_free (EmpathyTpStreamedMediaStream, priv->video);
 458
 459   (G_OBJECT_CLASS (empathy_tp_streamed_media_parent_class)->finalize) (object);
 460 }
 461
 462 static void
 463 tp_streamed_media_set_property (GObject *object,
 464                       guint prop_id,
 465                       const GValue *value,
 466                       GParamSpec *pspec)
 467 {
 468   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (object);
 469
 470   switch (prop_id)
 471     {
 472     case PROP_ACCOUNT:
 473       priv->account = g_value_dup_object (value);
 474       break;
 475     case PROP_CHANNEL:
 476       priv->channel = g_value_dup_object (value);
 477       break;
 478     default:
 479       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 480       break;
 481   }
 482 }
 483
 484 static void
 485 tp_streamed_media_get_property (GObject *object,
 486                       guint prop_id,
 487                       GValue *value,
 488                       GParamSpec *pspec)
 489 {
 490   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (object);
 491
 492   switch (prop_id)
 493     {
 494     case PROP_ACCOUNT:
 495       g_value_set_object (value, priv->channel);
 496       break;
 497     case PROP_CHANNEL:
 498       g_value_set_object (value, priv->channel);
 499       break;
 500     case PROP_CONTACT:
 501       g_value_set_object (value, priv->contact);
 502       break;
 503     case PROP_STATUS:
 504       g_value_set_uint (value, priv->status);
 505       break;
 506     case PROP_AUDIO_STREAM:
 507       g_value_set_pointer (value, priv->audio);
 508       break;
 509     case PROP_VIDEO_STREAM:
 510       g_value_set_pointer (value, priv->video);
 511       break;
 512     default:
 513       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 514       break;
 515   }
 516 }
 517
 518 static void
 519 empathy_tp_streamed_media_class_init (EmpathyTpStreamedMediaClass *klass)
 520 {
 521   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 522
 523   object_class->constructor = tp_streamed_media_constructor;
 524   object_class->dispose = tp_streamed_media_dispose;
 525   object_class->finalize = tp_streamed_media_finalize;
 526   object_class->set_property = tp_streamed_media_set_property;
 527   object_class->get_property = tp_streamed_media_get_property;
 528
 529   g_type_class_add_private (klass, sizeof (EmpathyTpStreamedMediaPriv));
 530
 531   g_object_class_install_property (object_class, PROP_ACCOUNT,
 532       g_param_spec_object ("account", "TpAccount", "TpAccount",
 533       TP_TYPE_ACCOUNT,
 534       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
 535       G_PARAM_STATIC_STRINGS));
 536
 537   g_object_class_install_property (object_class, PROP_CHANNEL,
 538       g_param_spec_object ("channel", "channel", "channel",
 539       TP_TYPE_CHANNEL,
 540       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
 541       G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 542
 543   g_object_class_install_property (object_class, PROP_CONTACT,
 544       g_param_spec_object ("contact", "Call contact", "Call contact",
 545       EMPATHY_TYPE_CONTACT,
 546       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 547
 548   g_object_class_install_property (object_class, PROP_STATUS,
 549       g_param_spec_uint ("status", "Call status",
 550       "Call status", 0, 255, 0, G_PARAM_READABLE | G_PARAM_STATIC_NICK |
 551       G_PARAM_STATIC_BLURB));
 552
 553   g_object_class_install_property (object_class, PROP_AUDIO_STREAM,
 554       g_param_spec_pointer ("audio-stream", "Audio stream data",
 555       "Audio stream data",
 556       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 557
 558   g_object_class_install_property (object_class, PROP_VIDEO_STREAM,
 559       g_param_spec_pointer ("video-stream", "Video stream data",
 560       "Video stream data",
 561       G_PARAM_READABLE | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 562
 563   signals[AUDIO_STREAM_ERROR] =
 564     g_signal_new ("audio-stream-error",
 565       G_TYPE_FROM_CLASS (klass),
 566       G_SIGNAL_RUN_LAST, 0,
 567       NULL, NULL,
 568       g_cclosure_marshal_generic,
 569       G_TYPE_NONE,
 570       2, G_TYPE_UINT, G_TYPE_STRING);
 571
 572   signals[VIDEO_STREAM_ERROR] =
 573     g_signal_new ("video-stream-error",
 574       G_TYPE_FROM_CLASS (klass),
 575       G_SIGNAL_RUN_LAST, 0,
 576       NULL, NULL,
 577       g_cclosure_marshal_generic,
 578       G_TYPE_NONE,
 579       2, G_TYPE_UINT, G_TYPE_STRING);
 580 }
 581
 582 static void
 583 empathy_tp_streamed_media_init (EmpathyTpStreamedMedia *call)
 584 {
 585   EmpathyTpStreamedMediaPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (call,
 586     EMPATHY_TYPE_TP_STREAMED_MEDIA, EmpathyTpStreamedMediaPriv);
 587
 588   call->priv = priv;
 589   priv->status = EMPATHY_TP_STREAMED_MEDIA_STATUS_READYING;
 590   priv->contact = NULL;
 591   priv->audio = g_slice_new0 (EmpathyTpStreamedMediaStream);
 592   priv->video = g_slice_new0 (EmpathyTpStreamedMediaStream);
 593   priv->audio->exists = FALSE;
 594   priv->video->exists = FALSE;
 595 }
 596
 597 EmpathyTpStreamedMedia *
 598 empathy_tp_streamed_media_new (TpAccount *account,
 599     TpChannel *channel)
 600 {
 601   g_return_val_if_fail (TP_IS_ACCOUNT (account), NULL);
 602   g_return_val_if_fail (TP_IS_CHANNEL (channel), NULL);
 603
 604   return g_object_new (EMPATHY_TYPE_TP_STREAMED_MEDIA,
 605       "account", account,
 606       "channel", channel,
 607       NULL);
 608 }
 609
 610 void
 611 empathy_tp_streamed_media_accept_incoming_call (EmpathyTpStreamedMedia *call)
 612 {
 613   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 614   TpHandle self_handle;
 615   GArray handles = {(gchar *) &self_handle, 1};
 616
 617   g_return_if_fail (EMPATHY_IS_TP_STREAMED_MEDIA (call));
 618   g_return_if_fail (priv->status == EMPATHY_TP_STREAMED_MEDIA_STATUS_PENDING);
 619
 620   if (!priv->is_incoming)
 621     return;
 622
 623   DEBUG ("Accepting incoming call");
 624
 625   self_handle = tp_channel_group_get_self_handle (priv->channel);
 626   tp_cli_channel_interface_group_call_add_members (priv->channel, -1,
 627       &handles, NULL, NULL, NULL, NULL, NULL);
 628 }
 629
 630 void
 631 empathy_tp_streamed_media_close (EmpathyTpStreamedMedia *call)
 632 {
 633   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 634
 635   g_return_if_fail (EMPATHY_IS_TP_STREAMED_MEDIA (call));
 636
 637   if (priv->status == EMPATHY_TP_STREAMED_MEDIA_STATUS_CLOSED)
 638       return;
 639
 640   DEBUG ("Closing channel");
 641
 642   tp_cli_channel_call_close (priv->channel, -1,
 643       NULL, NULL, NULL, NULL);
 644
 645   priv->status = EMPATHY_TP_STREAMED_MEDIA_STATUS_CLOSED;
 646   g_object_notify (G_OBJECT (call), "status");
 647 }
 648
 649 void
 650 empathy_tp_streamed_media_request_video_stream_direction (EmpathyTpStreamedMedia *call,
 651                                                 gboolean is_sending)
 652 {
 653   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 654   guint new_direction;
 655
 656   g_return_if_fail (EMPATHY_IS_TP_STREAMED_MEDIA (call));
 657   g_return_if_fail (priv->status == EMPATHY_TP_STREAMED_MEDIA_STATUS_ACCEPTED);
 658
 659   DEBUG ("Requesting video stream direction - is_sending: %d", is_sending);
 660
 661   if (!priv->video->exists)
 662     {
 663       if (is_sending)
 664           tp_streamed_media_request_streams_for_capabilities (call,
 665               EMPATHY_CAPABILITIES_VIDEO);
 666       return;
 667     }
 668
 669   if (is_sending)
 670       new_direction = priv->video->direction | TP_MEDIA_STREAM_DIRECTION_SEND;
 671   else
 672       new_direction = priv->video->direction & ~TP_MEDIA_STREAM_DIRECTION_SEND;
 673
 674   tp_cli_channel_type_streamed_media_call_request_stream_direction (priv->channel,
 675       -1, priv->video->id, new_direction,
 676       (tp_cli_channel_type_streamed_media_callback_for_request_stream_direction)
 677       tp_streamed_media_async_cb, NULL, NULL, G_OBJECT (call));
 678 }
 679
 680 void
 681 empathy_tp_streamed_media_start_tone (EmpathyTpStreamedMedia *call, TpDTMFEvent event)
 682 {
 683   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 684
 685   g_return_if_fail (EMPATHY_IS_TP_STREAMED_MEDIA (call));
 686   g_return_if_fail (priv->status == EMPATHY_TP_STREAMED_MEDIA_STATUS_ACCEPTED);
 687
 688   if (!priv->audio->exists)
 689       return;
 690
 691   tp_cli_channel_interface_dtmf_call_start_tone (priv->channel, -1,
 692       priv->audio->id, event,
 693       (tp_cli_channel_interface_dtmf_callback_for_start_tone) tp_streamed_media_async_cb,
 694       "starting tone", NULL, G_OBJECT (call));
 695 }
 696
 697 void
 698 empathy_tp_streamed_media_stop_tone (EmpathyTpStreamedMedia *call)
 699 {
 700   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 701
 702   g_return_if_fail (EMPATHY_IS_TP_STREAMED_MEDIA (call));
 703   g_return_if_fail (priv->status == EMPATHY_TP_STREAMED_MEDIA_STATUS_ACCEPTED);
 704
 705   if (!priv->audio->exists)
 706       return;
 707
 708   tp_cli_channel_interface_dtmf_call_stop_tone (priv->channel, -1,
 709       priv->audio->id,
 710       (tp_cli_channel_interface_dtmf_callback_for_stop_tone) tp_streamed_media_async_cb,
 711       "stoping tone", NULL, G_OBJECT (call));
 712 }
 713
 714 gboolean
 715 empathy_tp_streamed_media_has_dtmf (EmpathyTpStreamedMedia *call)
 716 {
 717   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 718
 719   g_return_val_if_fail (EMPATHY_IS_TP_STREAMED_MEDIA (call), FALSE);
 720
 721   return tp_proxy_has_interface_by_id (priv->channel,
 722       TP_IFACE_QUARK_CHANNEL_INTERFACE_DTMF);
 723 }
 724
 725 /**
 726  * empathy_tp_streamed_media_is_receiving_video:
 727  * @call: the call
 728  *
 729  * Indicates if the call is receiving video or not.
 730  *
 731  * Returns: %TRUE if the call is currently receiving video, %FALSE otherwise.
 732  */
 733 gboolean
 734 empathy_tp_streamed_media_is_receiving_video (EmpathyTpStreamedMedia *call)
 735 {
 736   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 737
 738   g_return_val_if_fail (EMPATHY_IS_TP_STREAMED_MEDIA (call), FALSE);
 739
 740   if (!priv->video->exists)
 741     return FALSE;
 742
 743   return priv->video->direction & TP_MEDIA_STREAM_DIRECTION_RECEIVE ?
 744       TRUE : FALSE;
 745 }
 746
 747 /**
 748  * empathy_tp_streamed_media_is_sending_video:
 749  * @call: the call
 750  *
 751  * Indicates if the call is sending video or not.
 752  *
 753  * Returns: %TRUE if the call is currently sending video, %FALSE otherwise.
 754  */
 755 gboolean
 756 empathy_tp_streamed_media_is_sending_video (EmpathyTpStreamedMedia *call)
 757 {
 758   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (call);
 759
 760   g_return_val_if_fail (EMPATHY_IS_TP_STREAMED_MEDIA (call), FALSE);
 761
 762   if (!priv->video->exists)
 763     return FALSE;
 764
 765   return priv->video->direction & TP_MEDIA_STREAM_DIRECTION_SEND ?
 766       TRUE : FALSE;
 767 }
 768
 769 const gchar *
 770 empathy_tp_streamed_media_get_connection_manager (EmpathyTpStreamedMedia *self)
 771 {
 772   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (self);
 773
 774   return tp_account_get_connection_manager (priv->account);
 775 }
 776
 777 gboolean
 778 empathy_tp_streamed_media_has_initial_video (EmpathyTpStreamedMedia *self)
 779 {
 780   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (self);
 781   GHashTable *props;
 782   gboolean initial_video;
 783   gboolean valid;
 784
 785   if (priv->channel == NULL)
 786     return FALSE;
 787
 788   g_object_get (priv->channel, "channel-properties", &props, NULL);
 789
 790   initial_video = tp_asv_get_boolean (props,
 791     TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA ".InitialVideo", &valid);
 792   if (!valid)
 793     initial_video = FALSE;
 794
 795   g_hash_table_unref (props);
 796   return initial_video;
 797 }
 798
 799 static void
 800 leave_remove_members_cb (TpChannel *proxy,
 801     const GError *error,
 802     gpointer user_data,
 803     GObject *weak_object)
 804 {
 805   EmpathyTpStreamedMedia *self = user_data;
 806
 807   if (error == NULL)
 808     return;
 809
 810   DEBUG ("RemoveMembers failed (%s); closing the channel", error->message);
 811   empathy_tp_streamed_media_close (self);
 812 }
 813
 814 void
 815 empathy_tp_streamed_media_leave (EmpathyTpStreamedMedia *self)
 816 {
 817   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (self);
 818   TpHandle self_handle;
 819   GArray array = { (gchar *) &self_handle, 1 };
 820
 821   if (!tp_proxy_has_interface_by_id (priv->channel,
 822         TP_IFACE_QUARK_CHANNEL_INTERFACE_GROUP))
 823     {
 824       empathy_tp_streamed_media_close (self);
 825       return;
 826     }
 827
 828   self_handle = tp_channel_group_get_self_handle (priv->channel);
 829   if (self_handle == 0)
 830     {
 831       /* we are not member of the channel */
 832       empathy_tp_streamed_media_close (self);
 833       return;
 834     }
 835
 836   tp_cli_channel_interface_group_call_remove_members (priv->channel, -1, &array,
 837       "", leave_remove_members_cb, self, NULL, G_OBJECT (self));
 838 }
 839
 840 EmpathyTpStreamedMediaStatus
 841 empathy_tp_streamed_media_get_status (EmpathyTpStreamedMedia *self)
 842 {
 843   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (self);
 844
 845   return priv->status;
 846 }
 847
 848 TpAccount *
 849 empathy_tp_streamed_media_get_account (EmpathyTpStreamedMedia *self)
 850 {
 851   EmpathyTpStreamedMediaPriv *priv = GET_PRIV (self);
 852
 853   return priv->account;
 854 }