2 * empathy-call-handler.c - Source for EmpathyCallHandler
3 * Copyright (C) 2008 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 "empathy-call-handler.h"
31 #include "empathy-dispatcher.h"
32 #include "empathy-marshal.h"
33 #include "empathy-utils.h"
35 G_DEFINE_TYPE(EmpathyCallHandler, empathy_call_handler, G_TYPE_OBJECT)
47 static guint signals[LAST_SIGNAL] = {0};
55 /* private structure */
58 gboolean dispose_has_run;
60 EmpathyContact *contact;
62 } EmpathyCallHandlerPriv;
64 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyCallHandler)
67 empathy_call_handler_dispose (GObject *object)
69 EmpathyCallHandlerPriv *priv = GET_PRIV (object);
71 if (priv->dispose_has_run)
74 priv->dispose_has_run = TRUE;
76 if (priv->contact != NULL)
77 g_object_unref (priv->contact);
81 if (priv->tfchannel != NULL)
82 g_object_unref (priv->tfchannel);
84 priv->tfchannel = NULL;
86 if (priv->call != NULL)
88 empathy_tp_call_close (priv->call);
89 g_object_unref (priv->call);
94 /* release any references held by the object here */
95 if (G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose)
96 G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose (object);
100 empathy_call_handler_finalize (GObject *object)
102 /* free any data held directly by the object here */
103 if (G_OBJECT_CLASS (empathy_call_handler_parent_class)->finalize)
104 G_OBJECT_CLASS (empathy_call_handler_parent_class)->finalize (object);
108 empathy_call_handler_init (EmpathyCallHandler *obj)
110 EmpathyCallHandlerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj,
111 EMPATHY_TYPE_CALL_HANDLER, EmpathyCallHandlerPriv);
117 empathy_call_handler_set_property (GObject *object,
118 guint property_id, const GValue *value, GParamSpec *pspec)
120 EmpathyCallHandlerPriv *priv = GET_PRIV (object);
125 priv->contact = g_value_dup_object (value);
128 priv->call = g_value_dup_object (value);
131 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
136 empathy_call_handler_get_property (GObject *object,
137 guint property_id, GValue *value, GParamSpec *pspec)
139 EmpathyCallHandlerPriv *priv = GET_PRIV (object);
144 g_value_set_object (value, priv->contact);
147 g_value_set_object (value, priv->call);
150 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
156 empathy_call_handler_class_init (EmpathyCallHandlerClass *klass)
158 GObjectClass *object_class = G_OBJECT_CLASS (klass);
159 GParamSpec *param_spec;
161 g_type_class_add_private (klass, sizeof (EmpathyCallHandlerPriv));
163 object_class->set_property = empathy_call_handler_set_property;
164 object_class->get_property = empathy_call_handler_get_property;
165 object_class->dispose = empathy_call_handler_dispose;
166 object_class->finalize = empathy_call_handler_finalize;
168 param_spec = g_param_spec_object ("contact",
169 "contact", "The remote contact",
170 EMPATHY_TYPE_CONTACT,
171 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
172 g_object_class_install_property (object_class, PROP_CONTACT, param_spec);
174 param_spec = g_param_spec_object ("tp-call",
175 "tp-call", "The calls channel wrapper",
176 EMPATHY_TYPE_TP_CALL,
177 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
178 g_object_class_install_property (object_class, PROP_TP_CALL, param_spec);
180 signals[CONFERENCE_ADDED] =
181 g_signal_new ("conference-added", G_TYPE_FROM_CLASS (klass),
182 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
183 g_cclosure_marshal_VOID__OBJECT,
185 1, FS_TYPE_CONFERENCE);
187 signals[SRC_PAD_ADDED] =
188 g_signal_new ("src-pad-added", G_TYPE_FROM_CLASS (klass),
189 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
190 _empathy_marshal_VOID__OBJECT_UINT,
192 2, GST_TYPE_PAD, G_TYPE_UINT);
194 signals[SINK_PAD_ADDED] =
195 g_signal_new ("sink-pad-added", G_TYPE_FROM_CLASS (klass),
196 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
197 _empathy_marshal_VOID__OBJECT_UINT,
199 2, GST_TYPE_PAD, G_TYPE_UINT);
201 signals[REQUEST_RESOURCE] =
202 g_signal_new ("request-resource", G_TYPE_FROM_CLASS (klass),
203 G_SIGNAL_RUN_LAST, 0,
204 g_signal_accumulator_true_handled, NULL,
205 _empathy_marshal_BOOLEAN__UINT_UINT,
206 G_TYPE_BOOLEAN, 2, G_TYPE_UINT, G_TYPE_UINT);
209 g_signal_new ("closed", G_TYPE_FROM_CLASS (klass),
210 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
211 g_cclosure_marshal_VOID__VOID,
217 empathy_call_handler_new_for_contact (EmpathyContact *contact)
219 return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER,
220 "contact", contact, NULL));
224 empathy_call_handler_new_for_channel (EmpathyTpCall *call)
226 return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER,
227 "tp-call", call, NULL));
231 empathy_call_handler_bus_message (EmpathyCallHandler *handler,
232 GstBus *bus, GstMessage *message)
234 EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
236 if (priv->tfchannel == NULL)
239 tf_channel_bus_message (priv->tfchannel, message);
243 empathy_call_handler_tf_channel_session_created_cb (TfChannel *tfchannel,
244 FsConference *conference, FsParticipant *participant,
245 EmpathyCallHandler *self)
247 g_signal_emit (G_OBJECT (self), signals[CONFERENCE_ADDED], 0,
248 GST_ELEMENT (conference));
252 empathy_call_handler_tf_stream_src_pad_added_cb (TfStream *stream,
253 GstPad *pad, FsCodec *codec, EmpathyCallHandler *handler)
257 g_object_get (stream, "media-type", &media_type, NULL);
259 g_signal_emit (G_OBJECT (handler), signals[SRC_PAD_ADDED], 0,
265 empathy_call_handler_tf_stream_request_resource_cb (TfStream *stream,
266 guint direction, EmpathyTpCall *call)
271 g_object_get (G_OBJECT (stream), "media-type", &media_type, NULL);
273 g_signal_emit (G_OBJECT (call),
274 signals[REQUEST_RESOURCE], 0, media_type, direction, &ret);
280 empathy_call_handler_tf_channel_stream_created_cb (TfChannel *tfchannel,
281 TfStream *stream, EmpathyCallHandler *handler)
286 g_signal_connect (stream, "src-pad-added",
287 G_CALLBACK (empathy_call_handler_tf_stream_src_pad_added_cb), handler);
288 g_signal_connect (stream, "request-resource",
289 G_CALLBACK (empathy_call_handler_tf_stream_request_resource_cb),
292 g_object_get (stream, "media-type", &media_type,
293 "sink-pad", &spad, NULL);
295 g_signal_emit (G_OBJECT (handler), signals[SINK_PAD_ADDED], 0,
298 gst_object_unref (spad);
302 empathy_call_handler_tf_channel_closed_cb (TfChannel *tfchannel,
303 EmpathyCallHandler *handler)
305 g_signal_emit (G_OBJECT (handler), signals[CLOSED], 0);
309 empathy_call_handler_tf_channel_codec_config_get_defaults (FsCodec *codecs)
314 for (i = 0; codecs[i].encoding_name != NULL; i++)
315 l = g_list_append (l, fs_codec_copy (codecs + i));
321 empathy_call_handler_tf_channel_codec_config_cb (TfChannel *channel,
322 guint stream_id, FsMediaType media_type, guint direction, gpointer user_data)
324 FsCodec audio_codecs[] = {
325 { FS_CODEC_ID_ANY, "SPEEX", FS_MEDIA_TYPE_AUDIO, 16000, },
326 { FS_CODEC_ID_ANY, "SPEEX", FS_MEDIA_TYPE_AUDIO, 8000, },
328 { FS_CODEC_ID_DISABLE, "DV", FS_MEDIA_TYPE_AUDIO, },
329 { FS_CODEC_ID_DISABLE, "MPA", FS_MEDIA_TYPE_AUDIO, },
330 { FS_CODEC_ID_DISABLE, "VORBIS", FS_MEDIA_TYPE_AUDIO, },
331 { FS_CODEC_ID_DISABLE, "MP3", FS_MEDIA_TYPE_AUDIO, },
334 FsCodec video_codecs[] = {
335 { FS_CODEC_ID_ANY, "H264", FS_MEDIA_TYPE_VIDEO, },
336 { FS_CODEC_ID_ANY, "THEORA", FS_MEDIA_TYPE_VIDEO, },
337 { FS_CODEC_ID_ANY, "H263", FS_MEDIA_TYPE_VIDEO, },
339 { FS_CODEC_ID_DISABLE, "DV", FS_MEDIA_TYPE_VIDEO, },
340 { FS_CODEC_ID_DISABLE, "JPEG", FS_MEDIA_TYPE_VIDEO, },
341 { FS_CODEC_ID_DISABLE, "MPV", FS_MEDIA_TYPE_VIDEO, },
347 case FS_MEDIA_TYPE_AUDIO:
348 return empathy_call_handler_tf_channel_codec_config_get_defaults
350 case FS_MEDIA_TYPE_VIDEO:
351 return empathy_call_handler_tf_channel_codec_config_get_defaults
359 empathy_call_handler_start_tpfs (EmpathyCallHandler *self)
361 EmpathyCallHandlerPriv *priv = GET_PRIV (self);
364 g_object_get (priv->call, "channel", &channel, NULL);
366 g_assert (channel != NULL);
368 priv->tfchannel = tf_channel_new (channel);
370 /* Set up the telepathy farsight channel */
371 g_signal_connect (priv->tfchannel, "session-created",
372 G_CALLBACK (empathy_call_handler_tf_channel_session_created_cb), self);
373 g_signal_connect (priv->tfchannel, "stream-created",
374 G_CALLBACK (empathy_call_handler_tf_channel_stream_created_cb), self);
375 g_signal_connect (priv->tfchannel, "closed",
376 G_CALLBACK (empathy_call_handler_tf_channel_closed_cb), self);
377 g_signal_connect (priv->tfchannel, "stream-get-codec-config",
378 G_CALLBACK (empathy_call_handler_tf_channel_codec_config_cb), self);
380 g_object_unref (channel);
384 empathy_call_handler_request_cb (EmpathyDispatchOperation *operation,
385 const GError *error, gpointer user_data)
387 EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (user_data);
388 EmpathyCallHandlerPriv *priv = GET_PRIV (self);
393 priv->call = EMPATHY_TP_CALL (
394 empathy_dispatch_operation_get_channel_wrapper (operation));
396 g_object_ref (priv->call);
398 empathy_call_handler_start_tpfs (self);
400 empathy_tp_call_to (priv->call, priv->contact);
402 empathy_dispatch_operation_claim (operation);
406 empathy_call_handler_contact_ready_cb (EmpathyContact *contact,
407 const GError *error, gpointer user_data, GObject *object)
409 EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (object);
410 EmpathyCallHandlerPriv *priv = GET_PRIV (self);
411 EmpathyDispatcher *dispatcher;
415 GHashTable *request = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
416 (GDestroyNotify) tp_g_value_slice_free);
418 g_assert (priv->contact != NULL);
420 dispatcher = empathy_dispatcher_dup_singleton ();
421 account = empathy_contact_get_account (priv->contact);
422 allowed = empathy_dispatcher_find_channel_class (dispatcher, account,
423 TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA, TP_HANDLE_TYPE_CONTACT);
425 if (!tp_strv_contains ((const gchar * const *)allowed,
426 TP_IFACE_CHANNEL ".TargetHandle"))
427 g_assert_not_reached ();
429 /* org.freedesktop.Telepathy.Channel.ChannelType */
430 value = tp_g_value_slice_new (G_TYPE_STRING);
431 g_value_set_string (value, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA);
432 g_hash_table_insert (request, TP_IFACE_CHANNEL ".ChannelType", value);
434 /* org.freedesktop.Telepathy.Channel.TargetHandleType */
435 value = tp_g_value_slice_new (G_TYPE_UINT);
436 g_value_set_uint (value, TP_HANDLE_TYPE_CONTACT);
437 g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandleType", value);
439 /* org.freedesktop.Telepathy.Channel.TargetHandle*/
440 value = tp_g_value_slice_new (G_TYPE_UINT);
441 g_value_set_uint (value, empathy_contact_get_handle (priv->contact));
442 g_hash_table_insert (request, TP_IFACE_CHANNEL ".TargetHandle", value);
444 empathy_dispatcher_create_channel (dispatcher, account,
445 request, empathy_call_handler_request_cb, self);
447 g_object_unref (dispatcher);
451 empathy_call_handler_start_call (EmpathyCallHandler *handler)
454 EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
456 if (priv->call == NULL)
458 empathy_contact_call_when_ready (priv->contact,
459 EMPATHY_CONTACT_READY_HANDLE,
460 empathy_call_handler_contact_ready_cb, NULL, NULL, G_OBJECT (handler));
464 empathy_call_handler_start_tpfs (handler);
465 empathy_tp_call_accept_incoming_call (priv->call);