src/empathy-chat-manager.c

   1 /*
   2  * empathy-chat-manager.c - Source for EmpathyChatManager
   3  * Copyright (C) 2010 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
  20 #include "config.h"
  21 #include "empathy-chat-manager.h"
  22
  23 #include <telepathy-glib/proxy-subclass.h>
  24 #include <telepathy-glib/telepathy-glib-dbus.h>
  25
  26 #include "empathy-chatroom-manager.h"
  27 #include "empathy-chat-window.h"
  28 #include "empathy-request-util.h"
  29 #include "empathy-ui-utils.h"
  30 #include "extensions.h"
  31
  32 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  33 #include "empathy-debug.h"
  34
  35 enum {
  36   CLOSED_CHATS_CHANGED,
  37   DISPLAYED_CHATS_CHANGED,
  38   LAST_SIGNAL
  39 };
  40
  41 static guint signals[LAST_SIGNAL];
  42
  43 static void svc_iface_init (gpointer, gpointer);
  44
  45 G_DEFINE_TYPE_WITH_CODE (EmpathyChatManager, empathy_chat_manager,
  46     G_TYPE_OBJECT,
  47     G_IMPLEMENT_INTERFACE (EMP_TYPE_SVC_CHAT_MANAGER,
  48         svc_iface_init)
  49     )
  50
  51 /* private structure */
  52 typedef struct _EmpathyChatManagerPriv EmpathyChatManagerPriv;
  53
  54 struct _EmpathyChatManagerPriv
  55 {
  56   EmpathyChatroomManager *chatroom_mgr;
  57   /* Queue of (ChatData *) representing the closed chats */
  58   GQueue *closed_queue;
  59
  60   guint num_displayed_chat;
  61
  62   /* account path -> (GHashTable<(owned gchar *) contact ID
  63    *                  -> (owned gchar *) non-NULL message>)
  64    */
  65   GHashTable *messages;
  66
  67   TpBaseClient *handler;
  68
  69   /* Cached to keep Folks in memory while empathy-chat is running; we don't
  70    * want to reload it each time the last chat window is closed
  71    * and re-opened. */
  72   EmpathyIndividualManager *individual_mgr;
  73 };
  74
  75 #define GET_PRIV(o) \
  76   (G_TYPE_INSTANCE_GET_PRIVATE ((o), EMPATHY_TYPE_CHAT_MANAGER, \
  77     EmpathyChatManagerPriv))
  78
  79 static EmpathyChatManager *chat_manager_singleton = NULL;
  80
  81 typedef struct
  82 {
  83   TpAccount *account;
  84   gchar *id;
  85   gboolean room;
  86   gboolean sms;
  87 } ChatData;
  88
  89 static ChatData *
  90 chat_data_new (EmpathyChat *chat)
  91 {
  92   ChatData *data = NULL;
  93
  94   data = g_slice_new0 (ChatData);
  95
  96   data->account = g_object_ref (empathy_chat_get_account (chat));
  97   data->id = g_strdup (empathy_chat_get_id (chat));
  98   data->room = empathy_chat_is_room (chat);
  99   data->sms = empathy_chat_is_sms_channel (chat);
 100
 101   return data;
 102 }
 103
 104 static void
 105 chat_data_free (ChatData *data)
 106 {
 107   if (data->account != NULL)
 108     {
 109       g_object_unref (data->account);
 110       data->account = NULL;
 111     }
 112
 113   if (data->id != NULL)
 114     {
 115       g_free (data->id);
 116       data->id = NULL;
 117     }
 118
 119   g_slice_free (ChatData, data);
 120 }
 121
 122 static void
 123 chat_destroyed_cb (gpointer data,
 124     GObject *object)
 125 {
 126   EmpathyChatManager *self = data;
 127   EmpathyChatManagerPriv *priv = GET_PRIV (self);
 128
 129   priv->num_displayed_chat--;
 130
 131   DEBUG ("Chat destroyed; we are now displaying %u chats",
 132       priv->num_displayed_chat);
 133
 134   g_signal_emit (self, signals[DISPLAYED_CHATS_CHANGED], 0,
 135       priv->num_displayed_chat);
 136 }
 137
 138 static void
 139 join_cb (GObject *source,
 140     GAsyncResult *result,
 141     gpointer user_data)
 142 {
 143   TpChannel *channel = TP_CHANNEL (source);
 144   GError *error = NULL;
 145
 146   if (!tp_channel_join_finish (channel, result, &error))
 147     {
 148       DEBUG ("Failed to join chat (%s): %s",
 149           tp_channel_get_identifier (channel), error->message);
 150       g_error_free (error);
 151     }
 152 }
 153
 154 static void
 155 individual_mgr_cb (EmpathyChatWindow *window,
 156     GParamSpec *spec,
 157     EmpathyChatManager *self)
 158 {
 159   EmpathyChatManagerPriv *priv = GET_PRIV (self);
 160
 161   if (priv->individual_mgr != NULL)
 162     return;
 163
 164   priv->individual_mgr = empathy_chat_window_get_individual_manager (window);
 165   g_object_ref (priv->individual_mgr);
 166 }
 167
 168 static void
 169 process_tp_chat (EmpathyChatManager *self,
 170     EmpathyTpChat *tp_chat,
 171     TpAccount *account,
 172     gint64 user_action_time)
 173 {
 174   EmpathyChatManagerPriv *priv = GET_PRIV (self);
 175   EmpathyChat *chat = NULL;
 176   const gchar *id;
 177   EmpathyChatWindow *window;
 178
 179   id = empathy_tp_chat_get_id (tp_chat);
 180   if (!tp_str_empty (id))
 181     {
 182       chat = empathy_chat_window_find_chat (account, id,
 183           tp_text_channel_is_sms_channel ((TpTextChannel *) tp_chat));
 184     }
 185
 186   if (chat != NULL)
 187     {
 188       empathy_chat_set_tp_chat (chat, tp_chat);
 189     }
 190   else
 191     {
 192       GHashTable *chats = NULL;
 193
 194       chat = empathy_chat_new (tp_chat);
 195       /* empathy_chat_new returns a floating reference as EmpathyChat is
 196        * a GtkWidget. This reference will be taken by a container
 197        * (a GtkNotebook) when we'll call empathy_chat_window_present_chat */
 198
 199       priv->num_displayed_chat++;
 200
 201       DEBUG ("Chat displayed; we are now displaying %u chat",
 202           priv->num_displayed_chat);
 203
 204       g_signal_emit (self, signals[DISPLAYED_CHATS_CHANGED], 0,
 205           priv->num_displayed_chat);
 206
 207       /* Set the saved message in the channel if we have one. */
 208       chats = g_hash_table_lookup (priv->messages,
 209           tp_proxy_get_object_path (account));
 210
 211       if (chats != NULL)
 212         {
 213           const gchar *msg = g_hash_table_lookup (chats, id);
 214
 215           if (msg != NULL)
 216             empathy_chat_set_text (chat, msg);
 217         }
 218
 219       g_object_weak_ref ((GObject *) chat, chat_destroyed_cb, self);
 220     }
 221
 222   window = empathy_chat_window_present_chat (chat, user_action_time);
 223
 224   if (priv->individual_mgr == NULL)
 225     {
 226       /* We want to cache it as soon it's created */
 227       tp_g_signal_connect_object (window, "notify::individual-manager",
 228         G_CALLBACK (individual_mgr_cb), self, 0);
 229     }
 230
 231   if (empathy_tp_chat_is_invited (tp_chat, NULL))
 232     {
 233       /* We have been invited to the room. Add ourself as member as this
 234        * channel has been approved. */
 235       tp_channel_join_async (TP_CHANNEL (tp_chat), "", join_cb, self);
 236     }
 237 }
 238
 239 static void
 240 handle_channels (TpSimpleHandler *handler,
 241     TpAccount *account,
 242     TpConnection *connection,
 243     GList *channels,
 244     GList *requests_satisfied,
 245     gint64 user_action_time,
 246     TpHandleChannelsContext *context,
 247     gpointer user_data)
 248 {
 249   EmpathyChatManager *self = (EmpathyChatManager *) user_data;
 250   GList *l;
 251
 252   for (l = channels; l != NULL; l = g_list_next (l))
 253     {
 254       EmpathyTpChat *tp_chat = l->data;
 255
 256       if (tp_proxy_get_invalidated (tp_chat) != NULL)
 257         continue;
 258
 259       if (!EMPATHY_IS_TP_CHAT (tp_chat))
 260         {
 261           DEBUG ("Channel %s doesn't implement Messages; can't handle it",
 262               tp_proxy_get_object_path (tp_chat));
 263           continue;
 264         }
 265
 266       DEBUG ("Now handling channel %s", tp_proxy_get_object_path (tp_chat));
 267
 268       process_tp_chat (self, tp_chat, account, user_action_time);
 269     }
 270
 271   tp_handle_channels_context_accept (context);
 272 }
 273
 274 static void
 275 empathy_chat_manager_init (EmpathyChatManager *self)
 276 {
 277   EmpathyChatManagerPriv *priv = GET_PRIV (self);
 278   TpAccountManager *am;
 279   GError *error = NULL;
 280
 281   priv->closed_queue = g_queue_new ();
 282   priv->messages = g_hash_table_new_full (g_str_hash, g_str_equal,
 283       g_free, (GDestroyNotify) g_hash_table_unref);
 284
 285   am = tp_account_manager_dup ();
 286
 287   priv->chatroom_mgr = empathy_chatroom_manager_dup_singleton (NULL);
 288
 289   /* Text channels handler */
 290   priv->handler = tp_simple_handler_new_with_am (am, FALSE, FALSE,
 291       EMPATHY_CHAT_BUS_NAME_SUFFIX, FALSE, handle_channels, self, NULL);
 292
 293   g_object_unref (am);
 294
 295   tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
 296         TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_TEXT,
 297         TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_CONTACT,
 298         NULL));
 299
 300   tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
 301         TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_TEXT,
 302         TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_ROOM,
 303         NULL));
 304
 305   tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
 306         TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_TEXT,
 307         TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_NONE,
 308         NULL));
 309
 310   if (!tp_base_client_register (priv->handler, &error))
 311     {
 312       g_critical ("Failed to register text handler: %s", error->message);
 313       g_error_free (error);
 314     }
 315 }
 316
 317 static void
 318 empathy_chat_manager_finalize (GObject *object)
 319 {
 320   EmpathyChatManager *self = EMPATHY_CHAT_MANAGER (object);
 321   EmpathyChatManagerPriv *priv = GET_PRIV (self);
 322
 323   if (priv->closed_queue != NULL)
 324     {
 325       g_queue_foreach (priv->closed_queue, (GFunc) chat_data_free, NULL);
 326       g_queue_free (priv->closed_queue);
 327       priv->closed_queue = NULL;
 328     }
 329
 330   tp_clear_pointer (&priv->messages, g_hash_table_unref);
 331
 332   tp_clear_object (&priv->handler);
 333   tp_clear_object (&priv->chatroom_mgr);
 334   tp_clear_object (&priv->individual_mgr);
 335
 336   G_OBJECT_CLASS (empathy_chat_manager_parent_class)->finalize (object);
 337 }
 338
 339 static GObject *
 340 empathy_chat_manager_constructor (GType type,
 341     guint n_construct_params,
 342     GObjectConstructParam *construct_params)
 343 {
 344   GObject *retval;
 345
 346   if (!chat_manager_singleton)
 347     {
 348       retval = G_OBJECT_CLASS (empathy_chat_manager_parent_class)->constructor
 349         (type, n_construct_params, construct_params);
 350
 351       chat_manager_singleton = EMPATHY_CHAT_MANAGER (retval);
 352       g_object_add_weak_pointer (retval, (gpointer) &chat_manager_singleton);
 353     }
 354   else
 355     {
 356       retval = g_object_ref (chat_manager_singleton);
 357     }
 358
 359   return retval;
 360 }
 361
 362 static void
 363 empathy_chat_manager_constructed (GObject *obj)
 364 {
 365   TpDBusDaemon *dbus_daemon;
 366
 367   dbus_daemon = tp_dbus_daemon_dup (NULL);
 368
 369   if (dbus_daemon != NULL)
 370     {
 371       tp_dbus_daemon_register_object (dbus_daemon,
 372           "/org/gnome/Empathy/ChatManager", obj);
 373
 374       g_object_unref (dbus_daemon);
 375     }
 376 }
 377
 378 static void
 379 empathy_chat_manager_class_init (
 380   EmpathyChatManagerClass *empathy_chat_manager_class)
 381 {
 382   GObjectClass *object_class = G_OBJECT_CLASS (empathy_chat_manager_class);
 383
 384   object_class->finalize = empathy_chat_manager_finalize;
 385   object_class->constructor = empathy_chat_manager_constructor;
 386   object_class->constructed = empathy_chat_manager_constructed;
 387
 388   signals[CLOSED_CHATS_CHANGED] =
 389     g_signal_new ("closed-chats-changed",
 390         G_TYPE_FROM_CLASS (object_class),
 391         G_SIGNAL_RUN_LAST,
 392         0,
 393         NULL, NULL,
 394         g_cclosure_marshal_generic,
 395         G_TYPE_NONE,
 396         1, G_TYPE_UINT, NULL);
 397
 398   signals[DISPLAYED_CHATS_CHANGED] =
 399     g_signal_new ("displayed-chats-changed",
 400         G_TYPE_FROM_CLASS (object_class),
 401         G_SIGNAL_RUN_LAST,
 402         0,
 403         NULL, NULL,
 404         g_cclosure_marshal_generic,
 405         G_TYPE_NONE,
 406         1, G_TYPE_UINT, NULL);
 407
 408   g_type_class_add_private (empathy_chat_manager_class,
 409     sizeof (EmpathyChatManagerPriv));
 410 }
 411
 412 EmpathyChatManager *
 413 empathy_chat_manager_dup_singleton (void)
 414 {
 415   return g_object_new (EMPATHY_TYPE_CHAT_MANAGER, NULL);
 416 }
 417
 418 void
 419 empathy_chat_manager_closed_chat (EmpathyChatManager *self,
 420     EmpathyChat *chat)
 421 {
 422   EmpathyChatManagerPriv *priv = GET_PRIV (self);
 423   ChatData *data;
 424   GHashTable *chats;
 425   gchar *message;
 426
 427   data = chat_data_new (chat);
 428
 429   DEBUG ("Adding %s to closed queue: %s",
 430       data->room ? "room" : "contact", data->id);
 431
 432   g_queue_push_tail (priv->closed_queue, data);
 433
 434   g_signal_emit (self, signals[CLOSED_CHATS_CHANGED], 0,
 435       g_queue_get_length (priv->closed_queue));
 436
 437   /* If there was a message saved from last time it was closed
 438    * (perhaps by accident?) save it to our hash table so it can be
 439    * used again when the same chat pops up. Hot. */
 440   message = empathy_chat_dup_text (chat);
 441
 442   chats = g_hash_table_lookup (priv->messages,
 443       tp_proxy_get_object_path (data->account));
 444
 445   /* Don't create a new hash table if we don't already have one and we
 446    * don't actually have a message to save. */
 447   if (chats == NULL && tp_str_empty (message))
 448     {
 449       g_free (message);
 450       return;
 451     }
 452   else if (chats == NULL && !tp_str_empty (message))
 453     {
 454       chats = g_hash_table_new_full (g_str_hash, g_str_equal,
 455           g_free, g_free);
 456
 457       g_hash_table_insert (priv->messages,
 458           g_strdup (tp_proxy_get_object_path (data->account)),
 459           chats);
 460     }
 461
 462   if (tp_str_empty (message))
 463     {
 464       g_hash_table_remove (chats, data->id);
 465       /* might be '\0' */
 466       g_free (message);
 467     }
 468   else
 469     {
 470       /* takes ownership of message */
 471       g_hash_table_insert (chats, g_strdup (data->id), message);
 472     }
 473 }
 474
 475 void
 476 empathy_chat_manager_undo_closed_chat (EmpathyChatManager *self,
 477     gint64 timestamp)
 478 {
 479   EmpathyChatManagerPriv *priv = GET_PRIV (self);
 480   ChatData *data;
 481
 482   data = g_queue_pop_tail (priv->closed_queue);
 483
 484   if (data == NULL)
 485     return;
 486
 487   DEBUG ("Removing %s from closed queue and starting a chat with: %s",
 488       data->room ? "room" : "contact", data->id);
 489
 490   if (data->room)
 491     empathy_join_muc (data->account, data->id, timestamp);
 492   else if (data->sms)
 493     empathy_sms_contact_id (data->account, data->id, timestamp,
 494         NULL, NULL);
 495   else
 496     empathy_chat_with_contact_id (data->account, data->id, timestamp,
 497         NULL, NULL);
 498
 499   g_signal_emit (self, signals[CLOSED_CHATS_CHANGED], 0,
 500       g_queue_get_length (priv->closed_queue));
 501
 502   chat_data_free (data);
 503 }
 504
 505 guint
 506 empathy_chat_manager_get_num_closed_chats (EmpathyChatManager *self)
 507 {
 508   EmpathyChatManagerPriv *priv = GET_PRIV (self);
 509
 510   return g_queue_get_length (priv->closed_queue);
 511 }
 512
 513 static void
 514 empathy_chat_manager_dbus_undo_closed_chat (EmpSvcChatManager *manager,
 515     gint64 timestamp,
 516     DBusGMethodInvocation *context)
 517 {
 518   empathy_chat_manager_undo_closed_chat ((EmpathyChatManager *) manager,
 519       timestamp);
 520
 521   emp_svc_chat_manager_return_from_undo_closed_chat (context);
 522 }
 523
 524 static void
 525 svc_iface_init (gpointer g_iface,
 526     gpointer iface_data)
 527 {
 528   EmpSvcChatManagerClass *klass = (EmpSvcChatManagerClass *) g_iface;
 529
 530 #define IMPLEMENT(x) emp_svc_chat_manager_implement_##x (\
 531     klass, empathy_chat_manager_dbus_##x)
 532   IMPLEMENT(undo_closed_chat);
 533 #undef IMPLEMENT
 534 }
 535
 536 void
 537 empathy_chat_manager_call_undo_closed_chat (void)
 538 {
 539   TpDBusDaemon *dbus_daemon = tp_dbus_daemon_dup (NULL);
 540   TpProxy *proxy;
 541
 542   if (dbus_daemon == NULL)
 543     return;
 544
 545   proxy = g_object_new (TP_TYPE_PROXY,
 546       "dbus-daemon", dbus_daemon,
 547       "dbus-connection", tp_proxy_get_dbus_connection (TP_PROXY (dbus_daemon)),
 548       "bus-name", EMPATHY_CHAT_BUS_NAME,
 549       "object-path", "/org/gnome/Empathy/ChatManager",
 550       NULL);
 551
 552   tp_proxy_add_interface_by_id (proxy, EMP_IFACE_QUARK_CHAT_MANAGER);
 553
 554   emp_cli_chat_manager_call_undo_closed_chat (proxy, -1, empathy_get_current_action_time (),
 555       NULL, NULL, NULL, NULL);
 556
 557   g_object_unref (proxy);
 558   g_object_unref (dbus_daemon);
 559 }