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