finch/gntmedia.c

   1 /**
   2  * @file gntmedia.c GNT Media API
   3  * @ingroup finch
   4  */
   5
   6 /* finch
   7  *
   8  * Finch is the legal property of its developers, whose names are too numerous
   9  * to list here.  Please refer to the COPYRIGHT file distributed with this
  10  * source distribution.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  25  */
  26
  27 #include <internal.h>
  28 #include "finch.h"
  29 #include "gntconv.h"
  30 #include "gntmedia.h"
  31
  32 #include "gnt.h"
  33 #include "gntbutton.h"
  34 #include "gntbox.h"
  35 #include "gntlabel.h"
  36
  37 #include "cmds.h"
  38 #include "conversation.h"
  39 #include "debug.h"
  40 #include "mediamanager.h"
  41
  42 /* An incredibly large part of the following is from gtkmedia.c */
  43 #ifdef USE_VV
  44 #include "media-gst.h"
  45
  46 #undef hangup
  47
  48 #define FINCH_TYPE_MEDIA            (finch_media_get_type())
  49 #define FINCH_MEDIA(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), FINCH_TYPE_MEDIA, FinchMedia))
  50 #define FINCH_MEDIA_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), FINCH_TYPE_MEDIA, FinchMediaClass))
  51 #define FINCH_IS_MEDIA(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), FINCH_TYPE_MEDIA))
  52 #define FINCH_IS_MEDIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), FINCH_TYPE_MEDIA))
  53 #define FINCH_MEDIA_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), FINCH_TYPE_MEDIA, FinchMediaClass))
  54
  55 typedef struct _FinchMedia FinchMedia;
  56 typedef struct _FinchMediaClass FinchMediaClass;
  57 typedef struct _FinchMediaPrivate FinchMediaPrivate;
  58 typedef enum _FinchMediaState FinchMediaState;
  59
  60 struct _FinchMediaClass
  61 {
  62         GntBoxClass parent_class;
  63 };
  64
  65 struct _FinchMedia
  66 {
  67         GntBox parent;
  68         FinchMediaPrivate *priv;
  69 };
  70
  71 struct _FinchMediaPrivate
  72 {
  73         PurpleMedia *media;
  74
  75         GntWidget *accept;
  76         GntWidget *reject;
  77         GntWidget *hangup;
  78         GntWidget *calling;
  79
  80         PurpleConversation *conv;
  81 };
  82
  83 #define FINCH_MEDIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), FINCH_TYPE_MEDIA, FinchMediaPrivate))
  84
  85 static void finch_media_class_init (FinchMediaClass *klass);
  86 static void finch_media_init (FinchMedia *media);
  87 static void finch_media_finalize (GObject *object);
  88 static void finch_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
  89 static void finch_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
  90
  91 static GntBoxClass *parent_class = NULL;
  92
  93 enum {
  94         MESSAGE,
  95         LAST_SIGNAL
  96 };
  97 static guint finch_media_signals[LAST_SIGNAL] = {0};
  98
  99 enum {
 100         PROP_0,
 101         PROP_MEDIA,
 102 };
 103
 104 static GType
 105 finch_media_get_type(void)
 106 {
 107         static GType type = 0;
 108
 109         if (type == 0) {
 110                 static const GTypeInfo info = {
 111                         sizeof(FinchMediaClass),
 112                         NULL,
 113                         NULL,
 114                         (GClassInitFunc) finch_media_class_init,
 115                         NULL,
 116                         NULL,
 117                         sizeof(FinchMedia),
 118                         0,
 119                         (GInstanceInitFunc) finch_media_init,
 120                         NULL
 121                 };
 122                 type = g_type_register_static(GNT_TYPE_BOX, "FinchMedia", &info, 0);
 123         }
 124         return type;
 125 }
 126
 127
 128 static void
 129 finch_media_class_init (FinchMediaClass *klass)
 130 {
 131         GObjectClass *gobject_class = (GObjectClass*)klass;
 132         parent_class = g_type_class_peek_parent(klass);
 133
 134         gobject_class->finalize = finch_media_finalize;
 135         gobject_class->set_property = finch_media_set_property;
 136         gobject_class->get_property = finch_media_get_property;
 137
 138         g_object_class_install_property(gobject_class, PROP_MEDIA,
 139                         g_param_spec_object("media",
 140                         "PurpleMedia",
 141                         "The PurpleMedia associated with this media.",
 142                         PURPLE_TYPE_MEDIA,
 143                         G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
 144
 145         finch_media_signals[MESSAGE] = g_signal_new("message", G_TYPE_FROM_CLASS(klass),
 146                                         G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 147                                         g_cclosure_marshal_VOID__STRING,
 148                                         G_TYPE_NONE, 1, G_TYPE_STRING);
 149
 150         g_type_class_add_private(klass, sizeof(FinchMediaPrivate));
 151 }
 152
 153
 154 static void
 155 finch_media_init (FinchMedia *media)
 156 {
 157         media->priv = FINCH_MEDIA_GET_PRIVATE(media);
 158
 159         media->priv->calling = gnt_label_new(_("Calling..."));
 160         media->priv->hangup = gnt_button_new(_("Hangup"));
 161         media->priv->accept = gnt_button_new(_("Accept"));
 162         media->priv->reject = gnt_button_new(_("Reject"));
 163
 164         gnt_box_set_alignment(GNT_BOX(media), GNT_ALIGN_MID);
 165
 166         gnt_box_add_widget(GNT_BOX(media), media->priv->accept);
 167         gnt_box_add_widget(GNT_BOX(media), media->priv->reject);
 168 }
 169
 170 static void
 171 finch_media_finalize (GObject *media)
 172 {
 173         FinchMedia *gntmedia = FINCH_MEDIA(media);
 174         purple_debug_info("gntmedia", "finch_media_finalize\n");
 175         if (gntmedia->priv->media)
 176                 g_object_unref(gntmedia->priv->media);
 177 }
 178
 179 static void
 180 finch_media_emit_message(FinchMedia *gntmedia, const char *msg)
 181 {
 182         g_signal_emit(gntmedia, finch_media_signals[MESSAGE], 0, msg);
 183 }
 184
 185 static void
 186 finch_media_connected_cb(PurpleMedia *media, FinchMedia *gntmedia)
 187 {
 188         GntWidget *parent;
 189
 190         finch_media_emit_message(gntmedia, _("Call in progress."));
 191
 192         gnt_box_remove(GNT_BOX(gntmedia), gntmedia->priv->accept);
 193         gnt_box_remove(GNT_BOX(gntmedia), gntmedia->priv->reject);
 194         gnt_box_remove(GNT_BOX(gntmedia), gntmedia->priv->hangup);
 195         gnt_box_remove(GNT_BOX(gntmedia), gntmedia->priv->calling);
 196
 197         gnt_box_add_widget(GNT_BOX(gntmedia), gntmedia->priv->hangup);
 198
 199         gnt_widget_destroy(gntmedia->priv->accept);
 200         gnt_widget_destroy(gntmedia->priv->reject);
 201         gnt_widget_destroy(gntmedia->priv->calling);
 202         gntmedia->priv->accept = NULL;
 203         gntmedia->priv->reject = NULL;
 204         gntmedia->priv->calling = NULL;
 205
 206         parent = GNT_WIDGET(gntmedia);
 207         while (parent->parent)
 208                 parent = parent->parent;
 209         gnt_box_readjust(GNT_BOX(parent));
 210         gnt_widget_draw(parent);
 211 }
 212
 213 static void
 214 finch_media_wait_cb(PurpleMedia *media, FinchMedia *gntmedia)
 215 {
 216         GntWidget *parent;
 217
 218         gnt_box_remove(GNT_BOX(gntmedia), gntmedia->priv->accept);
 219         gnt_box_remove(GNT_BOX(gntmedia), gntmedia->priv->reject);
 220         gnt_box_remove(GNT_BOX(gntmedia), gntmedia->priv->hangup);
 221         gnt_box_remove(GNT_BOX(gntmedia), gntmedia->priv->calling);
 222
 223         gnt_box_add_widget(GNT_BOX(gntmedia), gntmedia->priv->calling);
 224         gnt_box_add_widget(GNT_BOX(gntmedia), gntmedia->priv->hangup);
 225
 226         parent = GNT_WIDGET(gntmedia);
 227         while (parent->parent)
 228                 parent = parent->parent;
 229         gnt_box_readjust(GNT_BOX(parent));
 230         gnt_widget_draw(parent);
 231 }
 232
 233 static void
 234 finch_media_state_changed_cb(PurpleMedia *media, PurpleMediaState state,
 235                 gchar *sid, gchar *name, FinchMedia *gntmedia)
 236 {
 237         purple_debug_info("gntmedia", "state: %d sid: %s name: %s\n",
 238                         state, sid, name);
 239         if (sid == NULL && name == NULL) {
 240                 if (state == PURPLE_MEDIA_STATE_END) {
 241                         finch_media_emit_message(gntmedia,
 242                                         _("The call has been terminated."));
 243                         finch_conversation_set_info_widget(
 244                                         gntmedia->priv->conv, NULL);
 245                         gnt_widget_destroy(GNT_WIDGET(gntmedia));
 246                         /*
 247                          * XXX: This shouldn't have to be here
 248                          * to free the FinchMedia widget.
 249                          */
 250                         g_object_unref(gntmedia);
 251                 }
 252         } else if (state == PURPLE_MEDIA_STATE_CONNECTED) {
 253                 finch_media_connected_cb(media, gntmedia);
 254         } else if (state == PURPLE_MEDIA_STATE_NEW &&
 255                         sid != NULL && name != NULL &&
 256                         purple_media_is_initiator(media, sid, name) == FALSE) {
 257                 PurpleAccount *account;
 258                 PurpleBuddy *buddy;
 259                 const gchar *alias;
 260                 PurpleMediaSessionType type =
 261                                 purple_media_get_session_type(media, sid);
 262                 gchar *message = NULL;
 263
 264                 account = purple_media_get_account(gntmedia->priv->media);
 265                 buddy = purple_find_buddy(account, name);
 266                 alias = buddy ? purple_buddy_get_contact_alias(buddy) : name;
 267
 268                 if (type & PURPLE_MEDIA_AUDIO) {
 269                         message = g_strdup_printf(
 270                                         _("%s wishes to start an audio session with you."),
 271                                         alias);
 272                 } else {
 273                         message = g_strdup_printf(
 274                                         _("%s is trying to start an unsupported media session type with you."),
 275                                         alias);
 276                 }
 277                 finch_media_emit_message(gntmedia, message);
 278                 g_free(message);
 279         }
 280 }
 281
 282 static void
 283 finch_media_stream_info_cb(PurpleMedia *media, PurpleMediaInfoType type,
 284                 gchar *sid, gchar *name, gboolean local, FinchMedia *gntmedia)
 285 {
 286         if (type == PURPLE_MEDIA_INFO_REJECT) {
 287                 finch_media_emit_message(gntmedia,
 288                                 _("You have rejected the call."));
 289         }
 290 }
 291
 292 static void
 293 finch_media_accept_cb(PurpleMedia *media, GntWidget *widget)
 294 {
 295         purple_media_stream_info(media, PURPLE_MEDIA_INFO_ACCEPT,
 296                         NULL, NULL, TRUE);
 297 }
 298
 299 static void
 300 finch_media_hangup_cb(PurpleMedia *media, GntWidget *widget)
 301 {
 302         purple_media_stream_info(media, PURPLE_MEDIA_INFO_HANGUP,
 303                         NULL, NULL, TRUE);
 304 }
 305
 306 static void
 307 finch_media_reject_cb(PurpleMedia *media, GntWidget *widget)
 308 {
 309         purple_media_stream_info(media, PURPLE_MEDIA_INFO_REJECT,
 310                         NULL, NULL, TRUE);
 311 }
 312
 313 static void
 314 finch_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 315 {
 316         FinchMedia *media;
 317         g_return_if_fail(FINCH_IS_MEDIA(object));
 318
 319         media = FINCH_MEDIA(object);
 320         switch (prop_id) {
 321                 case PROP_MEDIA:
 322                 {
 323                         if (media->priv->media)
 324                                 g_object_unref(media->priv->media);
 325                         media->priv->media = g_value_get_object(value);
 326                         g_object_ref(media->priv->media);
 327                         g_signal_connect_swapped(G_OBJECT(media->priv->accept), "activate",
 328                                  G_CALLBACK(finch_media_accept_cb), media->priv->media);
 329                         g_signal_connect_swapped(G_OBJECT(media->priv->reject), "activate",
 330                                  G_CALLBACK(finch_media_reject_cb), media->priv->media);
 331                         g_signal_connect_swapped(G_OBJECT(media->priv->hangup), "activate",
 332                                  G_CALLBACK(finch_media_hangup_cb), media->priv->media);
 333
 334                         if (purple_media_is_initiator(media->priv->media,
 335                                         NULL, NULL) == TRUE) {
 336                                 finch_media_wait_cb(media->priv->media, media);
 337                         }
 338                         g_signal_connect(G_OBJECT(media->priv->media), "state-changed",
 339                                 G_CALLBACK(finch_media_state_changed_cb), media);
 340                         g_signal_connect(G_OBJECT(media->priv->media), "stream-info",
 341                                 G_CALLBACK(finch_media_stream_info_cb), media);
 342                         break;
 343                 }
 344                 default:
 345                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 346                         break;
 347         }
 348 }
 349
 350 static void
 351 finch_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 352 {
 353         FinchMedia *media;
 354         g_return_if_fail(FINCH_IS_MEDIA(object));
 355
 356         media = FINCH_MEDIA(object);
 357
 358         switch (prop_id) {
 359                 case PROP_MEDIA:
 360                         g_value_set_object(value, media->priv->media);
 361                         break;
 362                 default:
 363                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 364                         break;
 365         }
 366 }
 367
 368 static GntWidget *
 369 finch_media_new(PurpleMedia *media)
 370 {
 371         return GNT_WIDGET(g_object_new(finch_media_get_type(),
 372                                 "media", media,
 373                                 "vertical", FALSE,
 374                                 "homogeneous", FALSE,
 375                                 NULL));
 376 }
 377
 378 static void
 379 gntmedia_message_cb(FinchMedia *gntmedia, const char *msg, PurpleConversation *conv)
 380 {
 381         if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 382                 purple_conv_im_write(PURPLE_CONV_IM(conv), NULL, msg, PURPLE_MESSAGE_SYSTEM, time(NULL));
 383         }
 384 }
 385
 386 static gboolean
 387 finch_new_media(PurpleMediaManager *manager, PurpleMedia *media,
 388                 PurpleAccount *account, gchar *name, gpointer null)
 389 {
 390         GntWidget *gntmedia;
 391         PurpleConversation *conv;
 392
 393         conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, name);
 394
 395         gntmedia = finch_media_new(media);
 396         g_signal_connect(G_OBJECT(gntmedia), "message", G_CALLBACK(gntmedia_message_cb), conv);
 397         FINCH_MEDIA(gntmedia)->priv->conv = conv;
 398         finch_conversation_set_info_widget(conv, gntmedia);
 399         return TRUE;
 400 }
 401
 402 static PurpleCmdRet
 403 call_cmd_cb(PurpleConversation *conv, const char *cmd, char **args,
 404                 char **eror, gpointer data)
 405 {
 406         PurpleAccount *account = purple_conversation_get_account(conv);
 407
 408         if (!purple_prpl_initiate_media(account,
 409                         purple_conversation_get_name(conv),
 410                         PURPLE_MEDIA_AUDIO))
 411                 return PURPLE_CMD_STATUS_FAILED;
 412
 413         return PURPLE_CMD_STATUS_OK;
 414 }
 415
 416 static GstElement *
 417 create_default_audio_src(PurpleMedia *media,
 418                 const gchar *session_id, const gchar *participant)
 419 {
 420         GstElement *src;
 421         src = gst_element_factory_make("gconfaudiosrc", NULL);
 422         if (src == NULL)
 423                 src = gst_element_factory_make("autoaudiosrc", NULL);
 424         if (src == NULL)
 425                 src = gst_element_factory_make("alsasrc", NULL);
 426         if (src == NULL)
 427                 src = gst_element_factory_make("osssrc", NULL);
 428         if (src == NULL)
 429                 src = gst_element_factory_make("dshowaudiosrc", NULL);
 430         if (src == NULL) {
 431                 purple_debug_error("gntmedia", "Unable to find a suitable "
 432                                 "element for the default audio source.\n");
 433                 return NULL;
 434         }
 435         gst_element_set_name(src, "finchdefaultaudiosrc");
 436         return src;
 437 }
 438
 439 static GstElement *
 440 create_default_audio_sink(PurpleMedia *media,
 441                 const gchar *session_id, const gchar *participant)
 442 {
 443         GstElement *sink;
 444         sink = gst_element_factory_make("gconfaudiosink", NULL);
 445         if (sink == NULL)
 446                 sink = gst_element_factory_make("autoaudiosink",NULL);
 447         if (sink == NULL) {
 448                 purple_debug_error("gntmedia", "Unable to find a suitable "
 449                                 "element for the default audio sink.\n");
 450                 return NULL;
 451         }
 452         return sink;
 453 }
 454 #endif  /* USE_VV */
 455
 456 void finch_media_manager_init(void)
 457 {
 458 #ifdef USE_VV
 459         PurpleMediaManager *manager = purple_media_manager_get();
 460         PurpleMediaElementInfo *default_audio_src =
 461                         g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
 462                         "id", "finchdefaultaudiosrc",
 463                         "name", "Finch Default Audio Source",
 464                         "type", PURPLE_MEDIA_ELEMENT_AUDIO
 465                                         | PURPLE_MEDIA_ELEMENT_SRC
 466                                         | PURPLE_MEDIA_ELEMENT_ONE_SRC
 467                                         | PURPLE_MEDIA_ELEMENT_UNIQUE,
 468                         "create-cb", create_default_audio_src, NULL);
 469         PurpleMediaElementInfo *default_audio_sink =
 470                         g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
 471                         "id", "finchdefaultaudiosink",
 472                         "name", "Finch Default Audio Sink",
 473                         "type", PURPLE_MEDIA_ELEMENT_AUDIO
 474                                         | PURPLE_MEDIA_ELEMENT_SINK
 475                                         | PURPLE_MEDIA_ELEMENT_ONE_SINK,
 476                         "create-cb", create_default_audio_sink, NULL);
 477
 478         g_signal_connect(G_OBJECT(manager), "init-media", G_CALLBACK(finch_new_media), NULL);
 479         purple_cmd_register("call", "", PURPLE_CMD_P_DEFAULT,
 480                         PURPLE_CMD_FLAG_IM, NULL,
 481                         call_cmd_cb, _("call: Make an audio call."), NULL);
 482
 483         purple_media_manager_set_ui_caps(manager,
 484                         PURPLE_MEDIA_CAPS_AUDIO |
 485                         PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION);
 486
 487         purple_debug_info("gntmedia", "Registering media element types\n");
 488         purple_media_manager_set_active_element(manager, default_audio_src);
 489         purple_media_manager_set_active_element(manager, default_audio_sink);
 490 #endif
 491 }
 492
 493 void finch_media_manager_uninit(void)
 494 {
 495 #ifdef USE_VV
 496         PurpleMediaManager *manager = purple_media_manager_get();
 497         g_signal_handlers_disconnect_by_func(G_OBJECT(manager),
 498                         G_CALLBACK(finch_new_media), NULL);
 499 #endif
 500 }
 501
 502