2 * empathy-call-handler.c - Source for EmpathyCallHandler
3 * Copyright (C) 2008-2009 Collabora Ltd.
4 * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
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.
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.
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
25 #include <telepathy-glib/util.h>
27 #include <telepathy-farsight/channel.h>
28 #include <telepathy-farsight/stream.h>
30 #include <gst/farsight/fs-element-added-notifier.h>
32 #include "empathy-call-handler.h"
33 #include "empathy-dispatcher.h"
34 #include "empathy-marshal.h"
35 #include "empathy-utils.h"
37 G_DEFINE_TYPE(EmpathyCallHandler, empathy_call_handler, G_TYPE_OBJECT)
49 static guint signals[LAST_SIGNAL] = {0};
59 /* private structure */
62 gboolean dispose_has_run;
64 EmpathyContact *contact;
66 gboolean initial_audio;
67 gboolean initial_video;
68 FsElementAddedNotifier *fsnotifier;
69 } EmpathyCallHandlerPriv;
71 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyCallHandler)
74 empathy_call_handler_dispose (GObject *object)
76 EmpathyCallHandlerPriv *priv = GET_PRIV (object);
78 if (priv->dispose_has_run)
81 priv->dispose_has_run = TRUE;
83 if (priv->contact != NULL)
84 g_object_unref (priv->contact);
88 if (priv->tfchannel != NULL)
89 g_object_unref (priv->tfchannel);
91 priv->tfchannel = NULL;
93 if (priv->call != NULL)
95 empathy_tp_call_close (priv->call);
96 g_object_unref (priv->call);
101 if (priv->fsnotifier != NULL)
103 g_object_unref (priv->fsnotifier);
105 priv->fsnotifier = NULL;
107 /* release any references held by the object here */
108 if (G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose)
109 G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose (object);
113 empathy_call_handler_finalize (GObject *object)
115 /* free any data held directly by the object here */
116 if (G_OBJECT_CLASS (empathy_call_handler_parent_class)->finalize)
117 G_OBJECT_CLASS (empathy_call_handler_parent_class)->finalize (object);
121 empathy_call_handler_init (EmpathyCallHandler *obj)
123 EmpathyCallHandlerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj,
124 EMPATHY_TYPE_CALL_HANDLER, EmpathyCallHandlerPriv);
130 empathy_call_handler_constructed (GObject *object)
132 EmpathyCallHandlerPriv *priv = GET_PRIV (object);
134 if (priv->contact == NULL)
136 g_object_get (priv->call, "contact", &(priv->contact), NULL);
141 empathy_call_handler_set_property (GObject *object,
142 guint property_id, const GValue *value, GParamSpec *pspec)
144 EmpathyCallHandlerPriv *priv = GET_PRIV (object);
149 priv->contact = g_value_dup_object (value);
152 priv->call = g_value_dup_object (value);
154 case PROP_INITIAL_AUDIO:
155 priv->initial_audio = g_value_get_boolean (value);
157 case PROP_INITIAL_VIDEO:
158 priv->initial_video = g_value_get_boolean (value);
161 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
166 empathy_call_handler_get_property (GObject *object,
167 guint property_id, GValue *value, GParamSpec *pspec)
169 EmpathyCallHandlerPriv *priv = GET_PRIV (object);
174 g_value_set_object (value, priv->contact);
177 g_value_set_object (value, priv->call);
179 case PROP_INITIAL_AUDIO:
180 g_value_set_boolean (value, priv->initial_audio);
182 case PROP_INITIAL_VIDEO:
183 g_value_set_boolean (value, priv->initial_video);
186 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
192 empathy_call_handler_class_init (EmpathyCallHandlerClass *klass)
194 GObjectClass *object_class = G_OBJECT_CLASS (klass);
195 GParamSpec *param_spec;
197 g_type_class_add_private (klass, sizeof (EmpathyCallHandlerPriv));
199 object_class->constructed = empathy_call_handler_constructed;
200 object_class->set_property = empathy_call_handler_set_property;
201 object_class->get_property = empathy_call_handler_get_property;
202 object_class->dispose = empathy_call_handler_dispose;
203 object_class->finalize = empathy_call_handler_finalize;
205 param_spec = g_param_spec_object ("contact",
206 "contact", "The remote contact",
207 EMPATHY_TYPE_CONTACT,
208 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
209 g_object_class_install_property (object_class, PROP_CONTACT, param_spec);
211 param_spec = g_param_spec_object ("tp-call",
212 "tp-call", "The calls channel wrapper",
213 EMPATHY_TYPE_TP_CALL,
214 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
215 g_object_class_install_property (object_class, PROP_TP_CALL, param_spec);
217 param_spec = g_param_spec_boolean ("initial-audio",
218 "initial-audio", "Whether the call should start with audio",
220 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
221 g_object_class_install_property (object_class, PROP_INITIAL_AUDIO,
224 param_spec = g_param_spec_boolean ("initial-video",
225 "initial-video", "Whether the call should start with video",
227 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
228 g_object_class_install_property (object_class, PROP_INITIAL_VIDEO,
231 signals[CONFERENCE_ADDED] =
232 g_signal_new ("conference-added", G_TYPE_FROM_CLASS (klass),
233 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
234 g_cclosure_marshal_VOID__OBJECT,
236 1, FS_TYPE_CONFERENCE);
238 signals[SRC_PAD_ADDED] =
239 g_signal_new ("src-pad-added", G_TYPE_FROM_CLASS (klass),
240 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
241 _empathy_marshal_VOID__OBJECT_UINT,
243 2, GST_TYPE_PAD, G_TYPE_UINT);
245 signals[SINK_PAD_ADDED] =
246 g_signal_new ("sink-pad-added", G_TYPE_FROM_CLASS (klass),
247 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
248 _empathy_marshal_VOID__OBJECT_UINT,
250 2, GST_TYPE_PAD, G_TYPE_UINT);
252 signals[REQUEST_RESOURCE] =
253 g_signal_new ("request-resource", G_TYPE_FROM_CLASS (klass),
254 G_SIGNAL_RUN_LAST, 0,
255 g_signal_accumulator_true_handled, NULL,
256 _empathy_marshal_BOOLEAN__UINT_UINT,
257 G_TYPE_BOOLEAN, 2, G_TYPE_UINT, G_TYPE_UINT);
260 g_signal_new ("closed", G_TYPE_FROM_CLASS (klass),
261 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
262 g_cclosure_marshal_VOID__VOID,
268 * empathy_call_handler_new_for_contact:
269 * @contact: an #EmpathyContact
271 * Creates a new #EmpathyCallHandler with contact @contact.
273 * Return value: a new #EmpathyCallHandler
276 empathy_call_handler_new_for_contact (EmpathyContact *contact)
278 return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER,
279 "contact", contact, NULL));
283 * empathy_call_handler_new_for_contact_with_streams:
284 * @contact: an #EmpathyContact
285 * @audio: if %TRUE the call will be started with audio
286 * @video: if %TRUE the call will be started with video
288 * Creates a new #EmpathyCallHandler with contact @contact.
290 * Return value: a new #EmpathyCallHandler
293 empathy_call_handler_new_for_contact_with_streams (EmpathyContact *contact,
294 gboolean audio, gboolean video)
296 return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER,
298 "initial-audio", audio,
299 "initial-video", video,
304 empathy_call_handler_new_for_channel (EmpathyTpCall *call)
306 return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER,
308 "initial-video", empathy_tp_call_is_receiving_video (call),
313 empathy_call_handler_bus_message (EmpathyCallHandler *handler,
314 GstBus *bus, GstMessage *message)
316 EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
318 if (priv->tfchannel == NULL)
321 tf_channel_bus_message (priv->tfchannel, message);
325 conference_element_added (FsElementAddedNotifier *notifier,
330 GstElementFactory *factory;
333 factory = gst_element_get_factory (element);
334 name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory));
336 if (!tp_strdiff (name, "x264enc"))
338 /* Ensure that the encoder creates the baseline profile */
339 g_object_set (element,
347 else if (!tp_strdiff (name, "gstrtpbin"))
349 /* Lower the jitterbuffer latency to make it more suitable for video
351 g_object_set (element, "latency", 100, NULL);
356 empathy_call_handler_tf_channel_session_created_cb (TfChannel *tfchannel,
357 FsConference *conference, FsParticipant *participant,
358 EmpathyCallHandler *self)
360 EmpathyCallHandlerPriv *priv = GET_PRIV (self);
362 priv->fsnotifier = fs_element_added_notifier_new ();
363 fs_element_added_notifier_add (priv->fsnotifier, GST_BIN (conference));
365 g_signal_connect (priv->fsnotifier, "element-added",
366 G_CALLBACK (conference_element_added), NULL);
368 g_signal_emit (G_OBJECT (self), signals[CONFERENCE_ADDED], 0,
369 GST_ELEMENT (conference));
373 empathy_call_handler_tf_stream_src_pad_added_cb (TfStream *stream,
374 GstPad *pad, FsCodec *codec, EmpathyCallHandler *handler)
378 g_object_get (stream, "media-type", &media_type, NULL);
380 g_signal_emit (G_OBJECT (handler), signals[SRC_PAD_ADDED], 0,
386 empathy_call_handler_tf_stream_request_resource_cb (TfStream *stream,
387 guint direction, EmpathyTpCall *call)
392 g_object_get (G_OBJECT (stream), "media-type", &media_type, NULL);
394 g_signal_emit (G_OBJECT (call),
395 signals[REQUEST_RESOURCE], 0, media_type, direction, &ret);
401 empathy_call_handler_tf_channel_stream_created_cb (TfChannel *tfchannel,
402 TfStream *stream, EmpathyCallHandler *handler)
407 g_signal_connect (stream, "src-pad-added",
408 G_CALLBACK (empathy_call_handler_tf_stream_src_pad_added_cb), handler);
409 g_signal_connect (stream, "request-resource",
410 G_CALLBACK (empathy_call_handler_tf_stream_request_resource_cb),
413 g_object_get (stream, "media-type", &media_type,
414 "sink-pad", &spad, NULL);
416 g_signal_emit (G_OBJECT (handler), signals[SINK_PAD_ADDED], 0,
419 gst_object_unref (spad);
423 empathy_call_handler_tf_channel_closed_cb (TfChannel *tfchannel,
424 EmpathyCallHandler *handler)
426 g_signal_emit (G_OBJECT (handler), signals[CLOSED], 0);
430 empathy_call_handler_tf_channel_codec_config_get_defaults (FsCodec *codecs)
435 for (i = 0; codecs[i].encoding_name != NULL; i++)
436 l = g_list_append (l, fs_codec_copy (codecs + i));
442 empathy_call_handler_tf_channel_codec_config_cb (TfChannel *channel,
443 guint stream_id, FsMediaType media_type, guint direction, gpointer user_data)
445 FsCodec audio_codecs[] = {
446 { FS_CODEC_ID_ANY, "SPEEX", FS_MEDIA_TYPE_AUDIO, 16000, },
447 { FS_CODEC_ID_ANY, "SPEEX", FS_MEDIA_TYPE_AUDIO, 8000, },
449 { FS_CODEC_ID_DISABLE, "DV", FS_MEDIA_TYPE_AUDIO, },
450 { FS_CODEC_ID_DISABLE, "MPA", FS_MEDIA_TYPE_AUDIO, },
451 { FS_CODEC_ID_DISABLE, "VORBIS", FS_MEDIA_TYPE_AUDIO, },
452 { FS_CODEC_ID_DISABLE, "MP3", FS_MEDIA_TYPE_AUDIO, },
455 FsCodec video_codecs[] = {
456 { FS_CODEC_ID_ANY, "H264", FS_MEDIA_TYPE_VIDEO, },
457 { FS_CODEC_ID_ANY, "THEORA", FS_MEDIA_TYPE_VIDEO, },
458 { FS_CODEC_ID_ANY, "H263", FS_MEDIA_TYPE_VIDEO, },
460 { FS_CODEC_ID_DISABLE, "DV", FS_MEDIA_TYPE_VIDEO, },
461 { FS_CODEC_ID_DISABLE, "JPEG", FS_MEDIA_TYPE_VIDEO, },
462 { FS_CODEC_ID_DISABLE, "MPV", FS_MEDIA_TYPE_VIDEO, },
468 case FS_MEDIA_TYPE_AUDIO:
469 return empathy_call_handler_tf_channel_codec_config_get_defaults
471 case FS_MEDIA_TYPE_VIDEO:
472 return empathy_call_handler_tf_channel_codec_config_get_defaults
480 empathy_call_handler_start_tpfs (EmpathyCallHandler *self)
482 EmpathyCallHandlerPriv *priv = GET_PRIV (self);
485 g_object_get (priv->call, "channel", &channel, NULL);
487 g_assert (channel != NULL);
489 priv->tfchannel = tf_channel_new (channel);
491 /* Set up the telepathy farsight channel */
492 g_signal_connect (priv->tfchannel, "session-created",
493 G_CALLBACK (empathy_call_handler_tf_channel_session_created_cb), self);
494 g_signal_connect (priv->tfchannel, "stream-created",
495 G_CALLBACK (empathy_call_handler_tf_channel_stream_created_cb), self);
496 g_signal_connect (priv->tfchannel, "closed",
497 G_CALLBACK (empathy_call_handler_tf_channel_closed_cb), self);
498 g_signal_connect (priv->tfchannel, "stream-get-codec-config",
499 G_CALLBACK (empathy_call_handler_tf_channel_codec_config_cb), self);
501 g_object_unref (channel);
505 empathy_call_handler_request_cb (EmpathyDispatchOperation *operation,
506 const GError *error, gpointer user_data)
508 EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (user_data);
509 EmpathyCallHandlerPriv *priv = GET_PRIV (self);
514 priv->call = EMPATHY_TP_CALL (
515 empathy_dispatch_operation_get_channel_wrapper (operation));
517 g_object_ref (priv->call);
519 empathy_call_handler_start_tpfs (self);
521 empathy_tp_call_to (priv->call, priv->contact,
522 priv->initial_audio, priv->initial_video);
524 empathy_dispatch_operation_claim (operation);
528 empathy_call_handler_start_call (EmpathyCallHandler *handler)
531 EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
532 EmpathyDispatcher *dispatcher;
533 TpConnection *connection;
538 if (priv->call != NULL)
540 empathy_call_handler_start_tpfs (handler);
541 empathy_tp_call_accept_incoming_call (priv->call);
545 g_assert (priv->contact != NULL);
547 dispatcher = empathy_dispatcher_dup_singleton ();
548 connection = empathy_contact_get_connection (priv->contact);
549 classes = empathy_dispatcher_find_requestable_channel_classes
550 (dispatcher, connection, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
551 TP_HANDLE_TYPE_CONTACT, NULL);
556 g_list_free (classes);
558 request = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
559 (GDestroyNotify) tp_g_value_slice_free);
561 /* org.freedesktop.Telepathy.Channel.ChannelType */
562 value = tp_g_value_slice_new (G_TYPE_STRING);
563 g_value_set_string (value, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA);
564 g_hash_table_insert (request, TP_IFACE_CHANNEL ".ChannelType", value);
566 /* org.freedesktop.Telepathy.Channel.TargetHandleType */
567 value = tp_g_value_slice_new (G_TYPE_UINT);
568 g_value_set_uint (value, TP_HANDLE_TYPE_CONTACT);
569 g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandleType", value);
571 /* org.freedesktop.Telepathy.Channel.TargetHandle*/
572 value = tp_g_value_slice_new (G_TYPE_UINT);
573 g_value_set_uint (value, empathy_contact_get_handle (priv->contact));
574 g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandle", value);
576 empathy_dispatcher_create_channel (dispatcher, connection,
577 request, empathy_call_handler_request_cb, handler);
579 g_object_unref (dispatcher);
583 * empathy_call_handler_stop_call:
584 * @handler: an #EmpathyCallHandler
586 * Closes the #EmpathyCallHandler's call and frees its resources.
589 empathy_call_handler_stop_call (EmpathyCallHandler *handler)
591 EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
593 if (priv->call != NULL)
595 empathy_tp_call_close (priv->call);
596 g_object_unref (priv->call);
603 * empathy_call_handler_has_initial_video:
604 * @handler: an #EmpathyCallHandler
606 * Return %TRUE if the call managed by this #EmpathyCallHandler was
607 * created with video enabled
609 * Return value: %TRUE if the call was created as a video conversation.
612 empathy_call_handler_has_initial_video (EmpathyCallHandler *handler)
614 EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
616 return priv->initial_video;