src/empathy-call-handler.c

   1 /*
   2  * empathy-call-handler.c - Source for EmpathyCallHandler
   3  * Copyright (C) 2008-2009 Collabora Ltd.
   4  * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
   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
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include <telepathy-glib/account-channel-request.h>
  26 #include <telepathy-glib/util.h>
  27 #include <telepathy-glib/interfaces.h>
  28
  29 #include <telepathy-yell/telepathy-yell.h>
  30
  31 #include <telepathy-farstream/telepathy-farstream.h>
  32
  33 #include <libempathy/empathy-utils.h>
  34 #include <libempathy/empathy-tp-contact-factory.h>
  35
  36 #include <libempathy-gtk/empathy-call-utils.h>
  37
  38 #include "empathy-call-handler.h"
  39
  40 #define DEBUG_FLAG EMPATHY_DEBUG_VOIP
  41 #include <libempathy/empathy-debug.h>
  42
  43 G_DEFINE_TYPE(EmpathyCallHandler, empathy_call_handler, G_TYPE_OBJECT)
  44
  45 /* signal enum */
  46 enum {
  47   CONFERENCE_ADDED,
  48   CONFERENCE_REMOVED,
  49   SRC_PAD_ADDED,
  50   SINK_PAD_ADDED,
  51   SINK_PAD_REMOVED,
  52   CLOSED,
  53   CANDIDATES_CHANGED,
  54   STATE_CHANGED,
  55   LAST_SIGNAL
  56 };
  57
  58 static guint signals[LAST_SIGNAL] = {0};
  59
  60 enum {
  61   PROP_CALL_CHANNEL = 1,
  62   PROP_GST_BUS,
  63   PROP_CONTACT,
  64   PROP_MEMBERS,
  65   PROP_INITIAL_AUDIO,
  66   PROP_INITIAL_VIDEO,
  67   PROP_SEND_AUDIO_CODEC,
  68   PROP_SEND_VIDEO_CODEC,
  69   PROP_RECV_AUDIO_CODECS,
  70   PROP_RECV_VIDEO_CODECS,
  71   PROP_AUDIO_REMOTE_CANDIDATE,
  72   PROP_VIDEO_REMOTE_CANDIDATE,
  73   PROP_AUDIO_LOCAL_CANDIDATE,
  74   PROP_VIDEO_LOCAL_CANDIDATE,
  75 };
  76
  77 /* private structure */
  78
  79 struct _EmpathyCallHandlerPriv {
  80   TpyCallChannel *call;
  81
  82   EmpathyContact *contact;
  83   /* GArray of TpContacts */
  84   GArray *members;
  85   TfChannel *tfchannel;
  86   gboolean initial_audio;
  87   gboolean initial_video;
  88
  89   FsCodec *send_audio_codec;
  90   FsCodec *send_video_codec;
  91   GList *recv_audio_codecs;
  92   GList *recv_video_codecs;
  93   FsCandidate *audio_remote_candidate;
  94   FsCandidate *video_remote_candidate;
  95   FsCandidate *audio_local_candidate;
  96   FsCandidate *video_local_candidate;
  97 };
  98
  99 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyCallHandler)
 100
 101 static void
 102 empathy_call_handler_dispose (GObject *object)
 103 {
 104   EmpathyCallHandlerPriv *priv = GET_PRIV (object);
 105
 106   tp_clear_object (&priv->tfchannel);
 107   tp_clear_object (&priv->call);
 108   tp_clear_object (&priv->contact);
 109
 110   tp_clear_pointer (&priv->members, g_array_unref);
 111
 112   G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose (object);
 113 }
 114
 115 static void
 116 empathy_call_handler_finalize (GObject *object)
 117 {
 118   EmpathyCallHandlerPriv *priv = GET_PRIV (object);
 119
 120   fs_codec_destroy (priv->send_audio_codec);
 121   fs_codec_destroy (priv->send_video_codec);
 122   fs_codec_list_destroy (priv->recv_audio_codecs);
 123   fs_codec_list_destroy (priv->recv_video_codecs);
 124   fs_candidate_destroy (priv->audio_remote_candidate);
 125   fs_candidate_destroy (priv->video_remote_candidate);
 126   fs_candidate_destroy (priv->audio_local_candidate);
 127   fs_candidate_destroy (priv->video_local_candidate);
 128
 129   G_OBJECT_CLASS (empathy_call_handler_parent_class)->finalize (object);
 130 }
 131
 132 static void
 133 empathy_call_handler_init (EmpathyCallHandler *obj)
 134 {
 135   EmpathyCallHandlerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj,
 136     EMPATHY_TYPE_CALL_HANDLER, EmpathyCallHandlerPriv);
 137
 138   obj->priv = priv;
 139 }
 140
 141 static void
 142 on_get_contacts_cb (TpConnection *connection,
 143     guint n_contacts,
 144     EmpathyContact * const * contacts,
 145     guint n_failed,
 146     const TpHandle *failed,
 147     const GError *error,
 148     gpointer user_data,
 149     GObject *weak_object)
 150 {
 151   EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (weak_object);
 152   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 153   guint i;
 154
 155   if (n_failed > 0)
 156     g_warning ("Failed to get %d EmpathyContacts: %s",
 157         n_failed, error->message);
 158
 159   priv->members = g_array_sized_new (FALSE, TRUE,
 160       sizeof (EmpathyContact *), n_contacts);
 161
 162   for (i = 0; i < n_contacts; i++)
 163     g_object_ref (contacts[i]);
 164
 165   g_array_append_vals (priv->members, contacts, n_contacts);
 166
 167   g_object_notify (G_OBJECT (self), "members");
 168 }
 169
 170 static void
 171 on_call_invalidated_cb (TpyCallChannel *call,
 172     guint domain,
 173     gint code,
 174     gchar *message,
 175     EmpathyCallHandler *self)
 176 {
 177   EmpathyCallHandlerPriv *priv = self->priv;
 178
 179   if (priv->call == call)
 180     {
 181       /* Invalidated unexpectedly? Fake call ending */
 182       g_signal_emit (self, signals[STATE_CHANGED], 0,
 183           TPY_CALL_STATE_ENDED, NULL);
 184       tp_clear_object (&priv->call);
 185       tp_clear_object (&priv->tfchannel);
 186     }
 187 }
 188
 189 static void
 190 on_call_state_changed_cb (TpyCallChannel *call,
 191   TpyCallState state,
 192   TpyCallFlags flags,
 193   const GValueArray *call_state_reason,
 194   GHashTable *call_state_details,
 195   EmpathyCallHandler *handler)
 196 {
 197   EmpathyCallHandlerPriv *priv = handler->priv;
 198   gchar *dbus_reason;
 199   guint actor, reason;
 200
 201   tp_value_array_unpack ((GValueArray *) call_state_reason, 3,
 202       &actor, &reason, &dbus_reason);
 203
 204   g_signal_emit (handler, signals[STATE_CHANGED], 0, state, dbus_reason);
 205
 206   if (state == TPY_CALL_STATE_ENDED)
 207     {
 208       tp_channel_close_async (TP_CHANNEL (call), NULL, NULL);
 209
 210       tp_clear_object (&priv->call);
 211       tp_clear_object (&priv->tfchannel);
 212     }
 213 }
 214
 215 static void
 216 on_members_changed_cb (TpyCallChannel *call,
 217     GHashTable *members,
 218     EmpathyCallHandler *self)
 219 {
 220   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 221   GHashTableIter iter;
 222   gpointer key, value;
 223   TpHandle *handles;
 224   guint n_handles;
 225   guint i = 0;
 226
 227   if (members == NULL)
 228     return;
 229
 230   n_handles = g_hash_table_size (members);
 231   if (n_handles == 0)
 232     return;
 233
 234   handles = g_new0 (TpHandle, n_handles);
 235
 236   g_hash_table_iter_init (&iter, members);
 237   while (g_hash_table_iter_next (&iter, &key, &value))
 238     handles[i++] = GPOINTER_TO_UINT (key);
 239
 240   empathy_tp_contact_factory_get_from_handles (
 241       tp_channel_borrow_connection (TP_CHANNEL (priv->call)),
 242       n_handles, handles,
 243       on_get_contacts_cb,
 244       NULL, NULL, G_OBJECT (self));
 245
 246   g_free (handles);
 247 }
 248
 249 static void
 250 empathy_call_handler_constructed (GObject *object)
 251 {
 252   EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (object);
 253   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 254 //  GHashTable *members;
 255
 256   g_signal_connect (priv->call, "members-changed",
 257       G_CALLBACK (on_members_changed_cb), object);
 258
 259 /* FIXME
 260   g_object_get (priv->call, "members", &members, NULL);
 261
 262   if (members)
 263     on_members_changed_cb (priv->call, members, self);
 264 */
 265 }
 266
 267 static void
 268 empathy_call_handler_set_property (GObject *object,
 269   guint property_id, const GValue *value, GParamSpec *pspec)
 270 {
 271   EmpathyCallHandlerPriv *priv = GET_PRIV (object);
 272
 273   switch (property_id)
 274     {
 275       case PROP_CONTACT:
 276         priv->contact = g_value_dup_object (value);
 277         break;
 278       case PROP_MEMBERS:
 279         priv->members = g_value_get_boxed (value);
 280         break;
 281       case PROP_CALL_CHANNEL:
 282         g_return_if_fail (priv->call == NULL);
 283
 284         priv->call = g_value_dup_object (value);
 285
 286         tp_g_signal_connect_object (priv->call, "state-changed",
 287           G_CALLBACK (on_call_state_changed_cb), object, 0);
 288         tp_g_signal_connect_object (priv->call, "invalidated",
 289           G_CALLBACK (on_call_invalidated_cb), object, 0);
 290         break;
 291       case PROP_INITIAL_AUDIO:
 292         priv->initial_audio = g_value_get_boolean (value);
 293         break;
 294       case PROP_INITIAL_VIDEO:
 295         priv->initial_video = g_value_get_boolean (value);
 296         break;
 297       default:
 298         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 299     }
 300 }
 301
 302 static void
 303 empathy_call_handler_get_property (GObject *object,
 304   guint property_id, GValue *value, GParamSpec *pspec)
 305 {
 306   EmpathyCallHandlerPriv *priv = GET_PRIV (object);
 307
 308   switch (property_id)
 309     {
 310       case PROP_CONTACT:
 311         g_value_set_object (value, priv->contact);
 312         break;
 313       case PROP_MEMBERS:
 314         g_value_set_boxed (value, priv->members);
 315         break;
 316       case PROP_CALL_CHANNEL:
 317         g_value_set_object (value, priv->call);
 318         break;
 319       case PROP_INITIAL_AUDIO:
 320         g_value_set_boolean (value, priv->initial_audio);
 321         break;
 322       case PROP_INITIAL_VIDEO:
 323         g_value_set_boolean (value, priv->initial_video);
 324         break;
 325       case PROP_SEND_AUDIO_CODEC:
 326         g_value_set_boxed (value, priv->send_audio_codec);
 327         break;
 328       case PROP_SEND_VIDEO_CODEC:
 329         g_value_set_boxed (value, priv->send_video_codec);
 330         break;
 331       case PROP_RECV_AUDIO_CODECS:
 332         g_value_set_boxed (value, priv->recv_audio_codecs);
 333         break;
 334       case PROP_RECV_VIDEO_CODECS:
 335         g_value_set_boxed (value, priv->recv_video_codecs);
 336         break;
 337       case PROP_AUDIO_REMOTE_CANDIDATE:
 338         g_value_set_boxed (value, priv->audio_remote_candidate);
 339         break;
 340       case PROP_VIDEO_REMOTE_CANDIDATE:
 341         g_value_set_boxed (value, priv->video_remote_candidate);
 342         break;
 343       case PROP_AUDIO_LOCAL_CANDIDATE:
 344         g_value_set_boxed (value, priv->audio_local_candidate);
 345         break;
 346       case PROP_VIDEO_LOCAL_CANDIDATE:
 347         g_value_set_boxed (value, priv->video_local_candidate);
 348         break;
 349       default:
 350         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 351     }
 352 }
 353
 354
 355 static void
 356 empathy_call_handler_class_init (EmpathyCallHandlerClass *klass)
 357 {
 358   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 359   GParamSpec *param_spec;
 360
 361   g_type_class_add_private (klass, sizeof (EmpathyCallHandlerPriv));
 362
 363   object_class->constructed = empathy_call_handler_constructed;
 364   object_class->set_property = empathy_call_handler_set_property;
 365   object_class->get_property = empathy_call_handler_get_property;
 366   object_class->dispose = empathy_call_handler_dispose;
 367   object_class->finalize = empathy_call_handler_finalize;
 368
 369   param_spec = g_param_spec_object ("target-contact",
 370     "TargetContact", "The contact",
 371     EMPATHY_TYPE_CONTACT,
 372     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
 373   g_object_class_install_property (object_class, PROP_CONTACT, param_spec);
 374
 375   param_spec = g_param_spec_boxed ("members",
 376     "call members", "The call participants",
 377     G_TYPE_ARRAY,
 378     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
 379   g_object_class_install_property (object_class, PROP_MEMBERS, param_spec);
 380
 381   param_spec = g_param_spec_object ("call-channel",
 382     "call channel", "The call channel",
 383     TPY_TYPE_CALL_CHANNEL,
 384     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
 385   g_object_class_install_property (object_class, PROP_CALL_CHANNEL, param_spec);
 386
 387   param_spec = g_param_spec_boolean ("initial-audio",
 388     "initial-audio", "Whether the call should start with audio",
 389     TRUE,
 390     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
 391   g_object_class_install_property (object_class, PROP_INITIAL_AUDIO,
 392       param_spec);
 393
 394   param_spec = g_param_spec_boolean ("initial-video",
 395     "initial-video", "Whether the call should start with video",
 396     FALSE,
 397     G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
 398   g_object_class_install_property (object_class, PROP_INITIAL_VIDEO,
 399     param_spec);
 400
 401   param_spec = g_param_spec_boxed ("send-audio-codec",
 402     "send audio codec", "Codec used to encode the outgoing video stream",
 403     FS_TYPE_CODEC,
 404     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 405   g_object_class_install_property (object_class, PROP_SEND_AUDIO_CODEC,
 406     param_spec);
 407
 408   param_spec = g_param_spec_boxed ("send-video-codec",
 409     "send video codec", "Codec used to encode the outgoing video stream",
 410     FS_TYPE_CODEC,
 411     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 412   g_object_class_install_property (object_class, PROP_SEND_VIDEO_CODEC,
 413     param_spec);
 414
 415   param_spec = g_param_spec_boxed ("recv-audio-codecs",
 416     "recvs audio codec", "Codecs used to decode the incoming audio stream",
 417     FS_TYPE_CODEC_LIST,
 418     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 419   g_object_class_install_property (object_class, PROP_RECV_AUDIO_CODECS,
 420     param_spec);
 421
 422   param_spec = g_param_spec_boxed ("recv-video-codecs",
 423     "recvs video codec", "Codecs used to decode the incoming video stream",
 424     FS_TYPE_CODEC_LIST,
 425     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 426   g_object_class_install_property (object_class, PROP_RECV_VIDEO_CODECS,
 427     param_spec);
 428
 429   param_spec = g_param_spec_boxed ("audio-remote-candidate",
 430     "audio remote candidate",
 431     "Remote candidate used for the audio stream",
 432     FS_TYPE_CANDIDATE,
 433     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 434   g_object_class_install_property (object_class,
 435       PROP_AUDIO_REMOTE_CANDIDATE, param_spec);
 436
 437   param_spec = g_param_spec_boxed ("video-remote-candidate",
 438     "video remote candidate",
 439     "Remote candidate used for the video stream",
 440     FS_TYPE_CANDIDATE,
 441     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 442   g_object_class_install_property (object_class,
 443       PROP_VIDEO_REMOTE_CANDIDATE, param_spec);
 444
 445   param_spec = g_param_spec_boxed ("audio-local-candidate",
 446     "audio local candidate",
 447     "Local candidate used for the audio stream",
 448     FS_TYPE_CANDIDATE,
 449     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 450   g_object_class_install_property (object_class,
 451       PROP_AUDIO_REMOTE_CANDIDATE, param_spec);
 452
 453   param_spec = g_param_spec_boxed ("video-local-candidate",
 454     "video local candidate",
 455     "Local candidate used for the video stream",
 456     FS_TYPE_CANDIDATE,
 457     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 458   g_object_class_install_property (object_class,
 459       PROP_VIDEO_REMOTE_CANDIDATE, param_spec);
 460
 461   signals[CONFERENCE_ADDED] =
 462     g_signal_new ("conference-added", G_TYPE_FROM_CLASS (klass),
 463       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 464       g_cclosure_marshal_generic,
 465       G_TYPE_NONE,
 466       1, FS_TYPE_CONFERENCE);
 467
 468   signals[CONFERENCE_REMOVED] =
 469     g_signal_new ("conference-removed", G_TYPE_FROM_CLASS (klass),
 470       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 471       g_cclosure_marshal_generic,
 472       G_TYPE_NONE,
 473       1, FS_TYPE_CONFERENCE);
 474
 475   signals[SRC_PAD_ADDED] =
 476     g_signal_new ("src-pad-added", G_TYPE_FROM_CLASS (klass),
 477       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 478       g_cclosure_marshal_generic,
 479       G_TYPE_BOOLEAN,
 480       2, GST_TYPE_PAD, G_TYPE_UINT);
 481
 482   signals[SINK_PAD_ADDED] =
 483     g_signal_new ("sink-pad-added", G_TYPE_FROM_CLASS (klass),
 484       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 485       g_cclosure_marshal_generic,
 486       G_TYPE_BOOLEAN,
 487       2, GST_TYPE_PAD, G_TYPE_UINT);
 488
 489   signals[SINK_PAD_REMOVED] =
 490     g_signal_new ("sink-pad-removed", G_TYPE_FROM_CLASS (klass),
 491       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 492       g_cclosure_marshal_generic,
 493       G_TYPE_BOOLEAN,
 494       2, GST_TYPE_PAD, G_TYPE_UINT);
 495
 496   signals[CLOSED] =
 497     g_signal_new ("closed", G_TYPE_FROM_CLASS (klass),
 498       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 499       g_cclosure_marshal_generic,
 500       G_TYPE_NONE,
 501       0);
 502
 503   signals[CANDIDATES_CHANGED] =
 504     g_signal_new ("candidates-changed", G_TYPE_FROM_CLASS (klass),
 505       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 506       g_cclosure_marshal_generic,
 507       G_TYPE_NONE, 1, G_TYPE_UINT);
 508
 509   signals[STATE_CHANGED] =
 510     g_signal_new ("state-changed", G_TYPE_FROM_CLASS (klass),
 511       G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 512       g_cclosure_marshal_generic,
 513       G_TYPE_NONE, 1, G_TYPE_UINT);
 514 }
 515
 516 EmpathyCallHandler *
 517 empathy_call_handler_new_for_channel (TpyCallChannel *call,
 518   EmpathyContact *contact)
 519 {
 520   return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER,
 521     "call-channel", call,
 522     "initial-video", tpy_call_channel_has_initial_video (call),
 523     "target-contact", contact,
 524     NULL));
 525 }
 526
 527 static void
 528 update_sending_codec (EmpathyCallHandler *self,
 529     FsCodec *codec,
 530     FsSession *session)
 531 {
 532   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 533   FsMediaType type;
 534
 535   if (codec == NULL || session == NULL)
 536     return;
 537
 538   g_object_get (session, "media-type", &type, NULL);
 539
 540   if (type == FS_MEDIA_TYPE_AUDIO)
 541     {
 542       priv->send_audio_codec = fs_codec_copy (codec);
 543       g_object_notify (G_OBJECT (self), "send-audio-codec");
 544     }
 545   else if (type == FS_MEDIA_TYPE_VIDEO)
 546     {
 547       priv->send_video_codec = fs_codec_copy (codec);
 548       g_object_notify (G_OBJECT (self), "send-video-codec");
 549     }
 550 }
 551
 552 static void
 553 update_receiving_codec (EmpathyCallHandler *self,
 554     GList *codecs,
 555     FsStream *stream)
 556 {
 557   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 558   FsSession *session;
 559   FsMediaType type;
 560
 561   if (codecs == NULL || stream == NULL)
 562     return;
 563
 564   g_object_get (stream, "session", &session, NULL);
 565   if (session == NULL)
 566     return;
 567
 568   g_object_get (session, "media-type", &type, NULL);
 569
 570   if (type == FS_MEDIA_TYPE_AUDIO)
 571     {
 572       priv->recv_audio_codecs = fs_codec_list_copy (codecs);
 573       g_object_notify (G_OBJECT (self), "recv-audio-codecs");
 574     }
 575   else if (type == FS_MEDIA_TYPE_VIDEO)
 576     {
 577       priv->recv_video_codecs = fs_codec_list_copy (codecs);
 578       g_object_notify (G_OBJECT (self), "recv-video-codecs");
 579     }
 580
 581   g_object_unref (session);
 582 }
 583
 584 static void
 585 update_candidates (EmpathyCallHandler *self,
 586     FsCandidate *remote_candidate,
 587     FsCandidate *local_candidate,
 588     FsStream *stream)
 589 {
 590   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 591   FsSession *session;
 592   FsMediaType type;
 593
 594   if (stream == NULL)
 595     return;
 596
 597   g_object_get (stream, "session", &session, NULL);
 598   if (session == NULL)
 599     return;
 600
 601   g_object_get (session, "media-type", &type, NULL);
 602
 603   if (type == FS_MEDIA_TYPE_AUDIO)
 604     {
 605       if (remote_candidate != NULL)
 606         {
 607           fs_candidate_destroy (priv->audio_remote_candidate);
 608           priv->audio_remote_candidate = fs_candidate_copy (remote_candidate);
 609           g_object_notify (G_OBJECT (self), "audio-remote-candidate");
 610         }
 611
 612       if (local_candidate != NULL)
 613         {
 614           fs_candidate_destroy (priv->audio_local_candidate);
 615           priv->audio_local_candidate = fs_candidate_copy (local_candidate);
 616           g_object_notify (G_OBJECT (self), "audio-local-candidate");
 617         }
 618
 619       g_signal_emit (G_OBJECT (self), signals[CANDIDATES_CHANGED], 0,
 620           FS_MEDIA_TYPE_AUDIO);
 621     }
 622   else if (type == FS_MEDIA_TYPE_VIDEO)
 623     {
 624       if (remote_candidate != NULL)
 625         {
 626           fs_candidate_destroy (priv->video_remote_candidate);
 627           priv->video_remote_candidate = fs_candidate_copy (remote_candidate);
 628           g_object_notify (G_OBJECT (self), "video-remote-candidate");
 629         }
 630
 631       if (local_candidate != NULL)
 632         {
 633           fs_candidate_destroy (priv->video_local_candidate);
 634           priv->video_local_candidate = fs_candidate_copy (local_candidate);
 635           g_object_notify (G_OBJECT (self), "video-local-candidate");
 636         }
 637
 638       g_signal_emit (G_OBJECT (self), signals[CANDIDATES_CHANGED], 0,
 639           FS_MEDIA_TYPE_VIDEO);
 640     }
 641
 642   g_object_unref (session);
 643 }
 644
 645 void
 646 empathy_call_handler_bus_message (EmpathyCallHandler *handler,
 647   GstBus *bus, GstMessage *message)
 648 {
 649   EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
 650   const GstStructure *s = gst_message_get_structure (message);
 651
 652   if (priv->tfchannel == NULL)
 653     return;
 654
 655   if (s != NULL &&
 656       gst_structure_has_name (s, "farsight-send-codec-changed"))
 657     {
 658       const GValue *val;
 659       FsCodec *codec;
 660       FsSession *session;
 661
 662       DEBUG ("farsight-send-codec-changed");
 663
 664       val = gst_structure_get_value (s, "codec");
 665       codec = g_value_get_boxed (val);
 666
 667       val = gst_structure_get_value (s, "session");
 668       session = g_value_get_object (val);
 669
 670       update_sending_codec (handler, codec, session);
 671     }
 672   else if (s != NULL &&
 673       gst_structure_has_name (s, "farsight-recv-codecs-changed"))
 674     {
 675       const GValue *val;
 676       GList *codecs;
 677       FsStream *stream;
 678
 679       DEBUG ("farsight-recv-codecs-changed");
 680
 681       val = gst_structure_get_value (s, "codecs");
 682       codecs = g_value_get_boxed (val);
 683
 684       val = gst_structure_get_value (s, "stream");
 685       stream = g_value_get_object (val);
 686
 687       update_receiving_codec (handler, codecs, stream);
 688     }
 689   else if (s != NULL &&
 690       gst_structure_has_name (s, "farsight-new-active-candidate-pair"))
 691     {
 692       const GValue *val;
 693       FsCandidate *remote_candidate, *local_candidate;
 694       FsStream *stream;
 695
 696       DEBUG ("farsight-new-active-candidate-pair");
 697
 698       val = gst_structure_get_value (s, "remote-candidate");
 699       remote_candidate = g_value_get_boxed (val);
 700
 701       val = gst_structure_get_value (s, "local-candidate");
 702       local_candidate = g_value_get_boxed (val);
 703
 704       val = gst_structure_get_value (s, "stream");
 705       stream = g_value_get_object (val);
 706
 707       update_candidates (handler, remote_candidate, local_candidate, stream);
 708     }
 709
 710   tf_channel_bus_message (priv->tfchannel, message);
 711 }
 712
 713 static void
 714 on_tf_channel_conference_added_cb (TfChannel *tfchannel,
 715   GstElement *conference,
 716   EmpathyCallHandler *self)
 717 {
 718   g_signal_emit (G_OBJECT (self), signals[CONFERENCE_ADDED], 0,
 719     conference);
 720 }
 721
 722 static void
 723 on_tf_channel_conference_removed_cb (TfChannel *tfchannel,
 724   FsConference *conference,
 725   EmpathyCallHandler *self)
 726 {
 727   g_signal_emit (G_OBJECT (self), signals[CONFERENCE_REMOVED], 0,
 728     GST_ELEMENT (conference));
 729 }
 730
 731 static gboolean
 732 src_pad_added_error_idle (gpointer data)
 733 {
 734   TfContent *content = data;
 735
 736   tf_content_error (content, 0 /* FIXME */,
 737       "Could not link sink", NULL);
 738   g_object_unref (content);
 739
 740   return FALSE;
 741 }
 742
 743 static void
 744 on_tf_content_src_pad_added_cb (TfContent *content,
 745   guint handle,
 746   FsStream *stream,
 747   GstPad *pad,
 748   FsCodec *codec,
 749   EmpathyCallHandler *handler)
 750 {
 751   guint media_type;
 752   gboolean retval;
 753
 754   g_object_get (content, "media-type", &media_type, NULL);
 755
 756   g_signal_emit (G_OBJECT (handler), signals[SRC_PAD_ADDED], 0,
 757       pad, media_type, &retval);
 758
 759   if (!retval)
 760     g_idle_add (src_pad_added_error_idle, g_object_ref (content));
 761 }
 762
 763 static void
 764 on_tf_channel_content_added_cb (TfChannel *tfchannel,
 765   TfContent *content,
 766   EmpathyCallHandler *handler)
 767 {
 768   FsMediaType mtype;
 769   GstPad *spad;
 770   FsSession *session;
 771 //  FsStream *fs_stream;
 772   FsCodec *codec;
 773 //  GList *codecs;
 774   gboolean retval;
 775
 776   g_signal_connect (content, "src-pad-added",
 777       G_CALLBACK (on_tf_content_src_pad_added_cb), handler);
 778 #if 0
 779   g_signal_connect (content, "start-sending",
 780       G_CALLBACK (on_tf_content_start_sending_cb), handler);
 781   g_signal_connect (content, "stop-sending",
 782       G_CALLBACK (on_tf_content_stop_sending_cb), handler);
 783 #endif
 784
 785   g_object_get (content, "media-type", &mtype,
 786     "sink-pad", &spad, NULL);
 787
 788   g_signal_emit (G_OBJECT (handler), signals[SINK_PAD_ADDED], 0,
 789       spad, mtype, &retval);
 790
 791  if (!retval)
 792       tf_content_error (content, 0 /* FIXME */,
 793           "Could not link source", NULL);
 794
 795  /* Get sending codec */
 796  g_object_get (content, "fs-session", &session, NULL);
 797  g_object_get (session, "current-send-codec", &codec, NULL);
 798
 799  update_sending_codec (handler, codec, session);
 800
 801  tp_clear_object (&session);
 802  tp_clear_object (&codec);
 803
 804  /* Get receiving codec */
 805 /* FIXME
 806  g_object_get (content, "fs-stream", &fs_stream, NULL);
 807  g_object_get (fs_stream, "current-recv-codecs", &codecs, NULL);
 808
 809  update_receiving_codec (handler, codecs, fs_stream);
 810
 811  fs_codec_list_destroy (codecs);
 812  tp_clear_object (&fs_stream);
 813 */
 814
 815  gst_object_unref (spad);
 816 }
 817
 818 static void
 819 on_tf_channel_content_removed_cb (TfChannel *tfchannel,
 820   TfContent *content,
 821   EmpathyCallHandler *handler)
 822 {
 823   FsMediaType mtype;
 824   GstPad *spad;
 825   gboolean retval;
 826
 827   DEBUG ("removing content");
 828
 829   g_object_get (content, "media-type", &mtype,
 830     "sink-pad", &spad, NULL);
 831
 832   g_signal_emit (G_OBJECT (handler), signals[SINK_PAD_REMOVED], 0,
 833       spad, mtype, &retval);
 834
 835   if (!retval)
 836     {
 837       g_warning ("Could not remove content!");
 838
 839       tf_content_error (content, 0 /* FIXME */,
 840           "Could not link source", NULL);
 841     }
 842 }
 843
 844 static void
 845 on_tf_channel_closed_cb (TfChannel *tfchannel,
 846     EmpathyCallHandler *handler)
 847 {
 848   g_signal_emit (G_OBJECT (handler), signals[CLOSED], 0);
 849 }
 850
 851 static void
 852 on_tf_channel_ready (GObject *source,
 853     GAsyncResult *result,
 854     gpointer user_data)
 855 {
 856   EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (user_data);
 857   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 858   GError *error = NULL;
 859
 860   priv->tfchannel = TF_CHANNEL (g_async_initable_new_finish (
 861       G_ASYNC_INITABLE (source), result, NULL));
 862
 863   if (priv->tfchannel == NULL)
 864     {
 865       g_warning ("Failed to create Farstream channel: %s", error->message);
 866       g_error_free (error);
 867       return;
 868     }
 869
 870   /* Set up the telepathy farstream channel */
 871   g_signal_connect (priv->tfchannel, "closed",
 872       G_CALLBACK (on_tf_channel_closed_cb), self);
 873   g_signal_connect (priv->tfchannel, "fs-conference-added",
 874       G_CALLBACK (on_tf_channel_conference_added_cb), self);
 875   g_signal_connect (priv->tfchannel, "fs-conference-removed",
 876       G_CALLBACK (on_tf_channel_conference_removed_cb), self);
 877   g_signal_connect (priv->tfchannel, "content-added",
 878       G_CALLBACK (on_tf_channel_content_added_cb), self);
 879   g_signal_connect (priv->tfchannel, "content-removed",
 880       G_CALLBACK (on_tf_channel_content_removed_cb), self);
 881 }
 882
 883 static void
 884 empathy_call_handler_start_tpfs (EmpathyCallHandler *self)
 885 {
 886   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 887
 888   tf_channel_new_async (TP_CHANNEL (priv->call),
 889       on_tf_channel_ready, self);
 890 }
 891
 892 static void
 893 on_call_accepted_cb (GObject *source_object,
 894     GAsyncResult *res,
 895     gpointer user_data)
 896 {
 897   TpyCallChannel *call = TPY_CALL_CHANNEL (source_object);
 898   GError *error = NULL;
 899
 900   if (!tpy_call_channel_accept_finish (call, res, &error))
 901     {
 902       g_warning ("could not accept Call: %s", error->message);
 903       g_error_free (error);
 904     }
 905 }
 906
 907 static void
 908 empathy_call_handler_request_cb (GObject *source,
 909     GAsyncResult *result,
 910     gpointer user_data)
 911 {
 912   EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (user_data);
 913   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
 914   TpChannel *channel;
 915   GError *error = NULL;
 916   TpAccountChannelRequest *req = TP_ACCOUNT_CHANNEL_REQUEST (source);
 917
 918   channel = tp_account_channel_request_create_and_handle_channel_finish (req,
 919       result, NULL, &error);
 920   if (channel == NULL)
 921     {
 922       DEBUG ("Failed to create the channel: %s", error->message);
 923       g_error_free (error);
 924       return;
 925     }
 926
 927   if (!TPY_IS_CALL_CHANNEL (channel))
 928     {
 929       DEBUG ("The channel is not a Call channel!");
 930       return;
 931     }
 932
 933   priv->call = TPY_CALL_CHANNEL (channel);
 934   tp_g_signal_connect_object (priv->call, "state-changed",
 935     G_CALLBACK (on_call_state_changed_cb), self, 0);
 936   tp_g_signal_connect_object (priv->call, "invalidated",
 937     G_CALLBACK (on_call_invalidated_cb), self, 0);
 938
 939   g_object_notify (G_OBJECT (self), "call-channel");
 940
 941   empathy_call_handler_start_tpfs (self);
 942   tpy_call_channel_accept_async (priv->call, on_call_accepted_cb, NULL);
 943 }
 944
 945 void
 946 empathy_call_handler_start_call (EmpathyCallHandler *handler,
 947     gint64 timestamp)
 948 {
 949   EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
 950   TpAccountChannelRequest *req;
 951   TpAccount *account;
 952   GHashTable *request;
 953
 954   if (priv->call != NULL)
 955     {
 956       empathy_call_handler_start_tpfs (handler);
 957       tpy_call_channel_accept_async (priv->call, on_call_accepted_cb, NULL);
 958       return;
 959     }
 960
 961   /* No TpyCallChannel (we are redialing). Request a new call channel */
 962   g_assert (priv->contact != NULL);
 963
 964   account = empathy_contact_get_account (priv->contact);
 965   request = empathy_call_create_call_request (
 966       empathy_contact_get_id (priv->contact),
 967       priv->initial_audio, priv->initial_video);
 968
 969   req = tp_account_channel_request_new (account, request, timestamp);
 970
 971   tp_account_channel_request_create_and_handle_channel_async (req, NULL,
 972       empathy_call_handler_request_cb, handler);
 973
 974   g_object_unref (req);
 975   g_hash_table_unref (request);
 976 }
 977
 978 /**
 979  * empathy_call_handler_stop_call:
 980  * @handler: an #EmpathyCallHandler
 981  *
 982  * Closes the #EmpathyCallHandler's call and frees its resources.
 983  */
 984 void
 985 empathy_call_handler_stop_call (EmpathyCallHandler *handler)
 986 {
 987   EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
 988
 989   if (priv->call != NULL)
 990     {
 991       tpy_call_channel_hangup_async (priv->call,
 992           TPY_CALL_STATE_CHANGE_REASON_USER_REQUESTED,
 993           "", "", NULL, NULL);
 994       tp_channel_close_async (TP_CHANNEL (priv->call),
 995         NULL, NULL);
 996       tp_clear_object (&priv->call);
 997       tp_clear_object (&priv->tfchannel);
 998     }
 999 }
1000
1001 /**
1002  * empathy_call_handler_has_initial_video:
1003  * @handler: an #EmpathyCallHandler
1004  *
1005  * Return %TRUE if the call managed by this #EmpathyCallHandler was
1006  * created with video enabled
1007  *
1008  * Return value: %TRUE if the call was created as a video conversation.
1009  */
1010 gboolean
1011 empathy_call_handler_has_initial_video (EmpathyCallHandler *handler)
1012 {
1013   EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
1014
1015   return priv->initial_video;
1016 }
1017
1018 FsCodec *
1019 empathy_call_handler_get_send_audio_codec (EmpathyCallHandler *self)
1020 {
1021   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
1022
1023   return priv->send_audio_codec;
1024 }
1025
1026 FsCodec *
1027 empathy_call_handler_get_send_video_codec (EmpathyCallHandler *self)
1028 {
1029   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
1030
1031   return priv->send_video_codec;
1032 }
1033
1034 GList *
1035 empathy_call_handler_get_recv_audio_codecs (EmpathyCallHandler *self)
1036 {
1037   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
1038
1039   return priv->recv_audio_codecs;
1040 }
1041
1042 GList *
1043 empathy_call_handler_get_recv_video_codecs (EmpathyCallHandler *self)
1044 {
1045   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
1046
1047   return priv->recv_video_codecs;
1048 }
1049
1050 FsCandidate *
1051 empathy_call_handler_get_audio_remote_candidate (
1052     EmpathyCallHandler *self)
1053 {
1054   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
1055
1056   return priv->audio_remote_candidate;
1057 }
1058
1059 FsCandidate *
1060 empathy_call_handler_get_audio_local_candidate (
1061     EmpathyCallHandler *self)
1062 {
1063   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
1064
1065   return priv->audio_local_candidate;
1066 }
1067
1068 FsCandidate *
1069 empathy_call_handler_get_video_remote_candidate (
1070     EmpathyCallHandler *self)
1071 {
1072   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
1073
1074   return priv->video_remote_candidate;
1075 }
1076
1077 FsCandidate *
1078 empathy_call_handler_get_video_local_candidate (
1079     EmpathyCallHandler *self)
1080 {
1081   EmpathyCallHandlerPriv *priv = GET_PRIV (self);
1082
1083   return priv->video_local_candidate;
1084 }