Add empathy_tp_chat_get_connection() to direct access the channel's connection.
[empathy.git] / libempathy / empathy-tp-chat.c
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3  * Copyright (C) 2007-2008 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  * Authors: Xavier Claessens <xclaesse@gmail.com>
20  */
21
22 #include <config.h>
23
24 #include <string.h>
25
26 #include <telepathy-glib/channel.h>
27 #include <telepathy-glib/dbus.h>
28 #include <telepathy-glib/util.h>
29
30 #include "empathy-tp-chat.h"
31 #include "empathy-tp-contact-factory.h"
32 #include "empathy-contact-monitor.h"
33 #include "empathy-contact-list.h"
34 #include "empathy-marshal.h"
35 #include "empathy-time.h"
36 #include "empathy-utils.h"
37
38 #define DEBUG_FLAG EMPATHY_DEBUG_TP | EMPATHY_DEBUG_CHAT
39 #include "empathy-debug.h"
40
41 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyTpChat)
42 typedef struct {
43         gboolean               dispose_has_run;
44         EmpathyTpContactFactory *factory;
45         EmpathyContactMonitor *contact_monitor;
46         EmpathyContact        *user;
47         EmpathyContact        *remote_contact;
48         GList                 *members;
49         TpChannel             *channel;
50         gboolean               listing_pending_messages;
51         /* Queue of messages not signalled yet */
52         GQueue                *messages_queue;
53         /* Queue of messages signalled but not acked yet */
54         GQueue                *pending_messages_queue;
55         gboolean               had_properties_list;
56         GPtrArray             *properties;
57         gboolean               ready;
58 } EmpathyTpChatPriv;
59
60 typedef struct {
61         gchar          *name;
62         guint           id;
63         TpPropertyFlags flags;
64         GValue         *value;
65 } TpChatProperty;
66
67 static void tp_chat_iface_init         (EmpathyContactListIface *iface);
68
69 enum {
70         PROP_0,
71         PROP_CHANNEL,
72         PROP_REMOTE_CONTACT,
73         PROP_READY,
74 };
75
76 enum {
77         MESSAGE_RECEIVED,
78         SEND_ERROR,
79         CHAT_STATE_CHANGED,
80         PROPERTY_CHANGED,
81         DESTROY,
82         LAST_SIGNAL
83 };
84
85 static guint signals[LAST_SIGNAL];
86
87 G_DEFINE_TYPE_WITH_CODE (EmpathyTpChat, empathy_tp_chat, G_TYPE_OBJECT,
88                          G_IMPLEMENT_INTERFACE (EMPATHY_TYPE_CONTACT_LIST,
89                                                 tp_chat_iface_init));
90
91 static void acknowledge_messages (EmpathyTpChat *chat, GArray *ids);
92
93 static void
94 tp_chat_invalidated_cb (TpProxy       *proxy,
95                         guint          domain,
96                         gint           code,
97                         gchar         *message,
98                         EmpathyTpChat *chat)
99 {
100         EmpathyTpChatPriv *priv = GET_PRIV (chat);
101
102         DEBUG ("Channel invalidated: %s", message);
103         g_signal_emit (chat, signals[DESTROY], 0);
104
105         g_object_unref (priv->channel);
106         priv->channel = NULL;
107 }
108
109 static void
110 tp_chat_async_cb (TpChannel *proxy,
111                   const GError *error,
112                   gpointer user_data,
113                   GObject *weak_object)
114 {
115         if (error) {
116                 DEBUG ("Error %s: %s", (gchar*) user_data, error->message);
117         }
118 }
119
120 static void
121 tp_chat_add (EmpathyContactList *list,
122              EmpathyContact     *contact,
123              const gchar        *message)
124 {
125         EmpathyTpChatPriv *priv = GET_PRIV (list);
126         TpHandle           handle;
127         GArray             handles = {(gchar *) &handle, 1};
128
129         g_return_if_fail (EMPATHY_IS_TP_CHAT (list));
130         g_return_if_fail (EMPATHY_IS_CONTACT (contact));
131
132         handle = empathy_contact_get_handle (contact);
133         tp_cli_channel_interface_group_call_add_members (priv->channel, -1,
134                                                          &handles, NULL,
135                                                          NULL, NULL, NULL,
136                                                          NULL);
137 }
138
139 static void
140 tp_chat_remove (EmpathyContactList *list,
141                 EmpathyContact     *contact,
142                 const gchar        *message)
143 {
144         EmpathyTpChatPriv *priv = GET_PRIV (list);
145         TpHandle           handle;
146         GArray             handles = {(gchar *) &handle, 1};
147
148         g_return_if_fail (EMPATHY_IS_TP_CHAT (list));
149         g_return_if_fail (EMPATHY_IS_CONTACT (contact));
150
151         handle = empathy_contact_get_handle (contact);
152         tp_cli_channel_interface_group_call_remove_members (priv->channel, -1,
153                                                             &handles, NULL,
154                                                             NULL, NULL, NULL,
155                                                             NULL);
156 }
157
158 static GList *
159 tp_chat_get_members (EmpathyContactList *list)
160 {
161         EmpathyTpChatPriv *priv = GET_PRIV (list);
162         GList             *members = NULL;
163
164         g_return_val_if_fail (EMPATHY_IS_TP_CHAT (list), NULL);
165
166         if (priv->members) {
167                 members = g_list_copy (priv->members);
168                 g_list_foreach (members, (GFunc) g_object_ref, NULL);
169         } else {
170                 members = g_list_prepend (members, g_object_ref (priv->user));
171                 members = g_list_prepend (members, g_object_ref (priv->remote_contact));
172         }
173
174         return members;
175 }
176
177 static EmpathyContactMonitor *
178 tp_chat_get_monitor (EmpathyContactList *list)
179 {
180         EmpathyTpChatPriv *priv;
181
182         g_return_val_if_fail (EMPATHY_IS_TP_CHAT (list), NULL);
183
184         priv = GET_PRIV (list);
185
186         if (priv->contact_monitor == NULL) {
187                 priv->contact_monitor = empathy_contact_monitor_new_for_iface (list);
188         }
189
190         return priv->contact_monitor;
191 }
192
193 static void
194 tp_chat_emit_queued_messages (EmpathyTpChat *chat)
195 {
196         EmpathyTpChatPriv *priv = GET_PRIV (chat);
197         EmpathyMessage    *message;
198
199         /* Check if we can now emit some queued messages */
200         while ((message = g_queue_peek_head (priv->messages_queue)) != NULL) {
201                 if (empathy_message_get_sender (message) == NULL) {
202                         break;
203                 }
204
205                 DEBUG ("Queued message ready");
206                 g_queue_pop_head (priv->messages_queue);
207                 g_queue_push_tail (priv->pending_messages_queue, message);
208                 g_signal_emit (chat, signals[MESSAGE_RECEIVED], 0, message);
209         }
210 }
211
212 static void
213 tp_chat_got_sender_cb (EmpathyTpContactFactory *factory,
214                        GList                   *contacts,
215                        gpointer                 message,
216                        GObject                 *chat)
217 {
218         empathy_message_set_sender (message, contacts->data);
219         tp_chat_emit_queued_messages (EMPATHY_TP_CHAT (chat));
220 }
221
222 static void
223 tp_chat_build_message (EmpathyTpChat *chat,
224                        guint          id,
225                        guint          type,
226                        guint          timestamp,
227                        guint          from_handle,
228                        const gchar   *message_body)
229 {
230         EmpathyTpChatPriv *priv;
231         EmpathyMessage    *message;
232
233         priv = GET_PRIV (chat);
234
235         message = empathy_message_new (message_body);
236         empathy_message_set_tptype (message, type);
237         empathy_message_set_receiver (message, priv->user);
238         empathy_message_set_timestamp (message, timestamp);
239         empathy_message_set_id (message, id);
240         g_queue_push_tail (priv->messages_queue, message);
241
242         if (from_handle == 0) {
243                 empathy_message_set_sender (message, priv->user);
244                 tp_chat_emit_queued_messages (chat);
245         } else {
246                 empathy_tp_contact_factory_get_from_handles (priv->factory,
247                         1, &from_handle,
248                         tp_chat_got_sender_cb,
249                         message, NULL, G_OBJECT (chat));
250         }
251 }
252
253 static void
254 tp_chat_received_cb (TpChannel   *channel,
255                      guint        message_id,
256                      guint        timestamp,
257                      guint        from_handle,
258                      guint        message_type,
259                      guint        message_flags,
260                      const gchar *message_body,
261                      gpointer     user_data,
262                      GObject     *chat_)
263 {
264         EmpathyTpChat *chat = EMPATHY_TP_CHAT (chat_);
265         EmpathyTpChatPriv *priv = GET_PRIV (chat);
266
267         if (priv->channel == NULL)
268                 return;
269
270         if (priv->listing_pending_messages) {
271                 return;
272         }
273  
274         DEBUG ("Message received: %s", message_body);
275
276         if (message_flags & TP_CHANNEL_TEXT_MESSAGE_FLAG_NON_TEXT_CONTENT &&
277             !tp_strdiff (message_body, "")) {
278                 GArray *ids;
279
280                 DEBUG ("Empty message with NonTextContent, ignoring and acking.");
281
282                 ids = g_array_sized_new (FALSE, FALSE, sizeof (guint), 1);
283                 g_array_append_val (ids, message_id);
284                 acknowledge_messages (chat, ids);
285                 g_array_free (ids, TRUE);
286
287                 return;
288         }
289
290         tp_chat_build_message (chat,
291                                message_id,
292                                message_type,
293                                timestamp,
294                                from_handle,
295                                message_body);
296 }
297
298 static void
299 tp_chat_sent_cb (TpChannel   *channel,
300                  guint        timestamp,
301                  guint        message_type,
302                  const gchar *message_body,
303                  gpointer     user_data,
304                  GObject     *chat_)
305 {
306         EmpathyTpChat *chat = EMPATHY_TP_CHAT (chat_);
307         EmpathyTpChatPriv *priv = GET_PRIV (chat);
308
309         if (priv->channel == NULL)
310                 return;
311
312         DEBUG ("Message sent: %s", message_body);
313
314         tp_chat_build_message (chat,
315                                0,
316                                message_type,
317                                timestamp,
318                                0,
319                                message_body);
320 }
321
322 static void
323 tp_chat_send_error_cb (TpChannel   *channel,
324                        guint        error_code,
325                        guint        timestamp,
326                        guint        message_type,
327                        const gchar *message_body,
328                        gpointer     user_data,
329                        GObject     *chat)
330 {
331         EmpathyTpChatPriv *priv = GET_PRIV (chat);
332
333         if (priv->channel == NULL)
334                 return;
335
336         DEBUG ("Message sent error: %s (%d)", message_body, error_code);
337
338         tp_chat_build_message (EMPATHY_TP_CHAT (chat),
339                                0,
340                                message_type,
341                                timestamp,
342                                0,
343                                message_body);
344 }
345
346 static void
347 tp_chat_send_cb (TpChannel    *proxy,
348                  const GError *error,
349                  gpointer      user_data,
350                  GObject      *chat)
351 {
352         EmpathyMessage *message = EMPATHY_MESSAGE (user_data);
353
354         if (error) {
355                 DEBUG ("Error: %s", error->message);
356                 g_signal_emit (chat, signals[SEND_ERROR], 0, message,
357                                TP_CHANNEL_TEXT_SEND_ERROR_UNKNOWN);
358         }
359 }
360
361 typedef struct {
362         EmpathyTpChat *chat;
363         TpChannelChatState state;
364 } StateChangedData;
365
366 static void
367 tp_chat_state_changed_got_contact_cb (EmpathyTpContactFactory *factory,
368                                       GList                   *contacts,
369                                       gpointer                 user_data,
370                                       GObject                 *chat)
371 {
372         EmpathyContact *contact = contacts->data;
373         TpChannelChatState state;
374
375         state = GPOINTER_TO_UINT (user_data);
376         DEBUG ("Chat state changed for %s (%d): %d",
377                 empathy_contact_get_name (contact),
378                 empathy_contact_get_handle (contact), state);
379
380         g_signal_emit (chat, signals[CHAT_STATE_CHANGED], 0, contact, state);
381 }
382
383 static void
384 tp_chat_state_changed_cb (TpChannel *channel,
385                           TpHandle   handle,
386                           TpChannelChatState state,
387                           gpointer   user_data,
388                           GObject   *chat)
389 {
390         EmpathyTpChatPriv *priv = GET_PRIV (chat);
391
392         empathy_tp_contact_factory_get_from_handles (priv->factory, 1, &handle,
393                 tp_chat_state_changed_got_contact_cb, GUINT_TO_POINTER (state),
394                 NULL, chat);
395 }
396
397 static void
398 tp_chat_list_pending_messages_cb (TpChannel       *channel,
399                                   const GPtrArray *messages_list,
400                                   const GError    *error,
401                                   gpointer         user_data,
402                                   GObject         *chat_)
403 {
404         EmpathyTpChat     *chat = EMPATHY_TP_CHAT (chat_);
405         EmpathyTpChatPriv *priv = GET_PRIV (chat);
406         guint              i;
407         GArray            *empty_non_text_content_ids = NULL;
408
409         priv->listing_pending_messages = FALSE;
410
411         if (priv->channel == NULL)
412                 return;
413
414         if (error) {
415                 DEBUG ("Error listing pending messages: %s", error->message);
416                 return;
417         }
418
419         for (i = 0; i < messages_list->len; i++) {
420                 GValueArray    *message_struct;
421                 const gchar    *message_body;
422                 guint           message_id;
423                 guint           timestamp;
424                 guint           from_handle;
425                 guint           message_type;
426                 guint           message_flags;
427
428                 message_struct = g_ptr_array_index (messages_list, i);
429
430                 message_id = g_value_get_uint (g_value_array_get_nth (message_struct, 0));
431                 timestamp = g_value_get_uint (g_value_array_get_nth (message_struct, 1));
432                 from_handle = g_value_get_uint (g_value_array_get_nth (message_struct, 2));
433                 message_type = g_value_get_uint (g_value_array_get_nth (message_struct, 3));
434                 message_flags = g_value_get_uint (g_value_array_get_nth (message_struct, 4));
435                 message_body = g_value_get_string (g_value_array_get_nth (message_struct, 5));
436
437                 DEBUG ("Message pending: %s", message_body);
438
439                 if (message_flags & TP_CHANNEL_TEXT_MESSAGE_FLAG_NON_TEXT_CONTENT &&
440                     !tp_strdiff (message_body, "")) {
441                         DEBUG ("Empty message with NonTextContent, ignoring and acking.");
442
443                         if (empty_non_text_content_ids == NULL) {
444                                 empty_non_text_content_ids = g_array_new (FALSE, FALSE, sizeof (guint));
445                         }
446
447                         g_array_append_val (empty_non_text_content_ids, message_id);
448                         continue;
449                 }
450
451                 tp_chat_build_message (chat,
452                                        message_id,
453                                        message_type,
454                                        timestamp,
455                                        from_handle,
456                                        message_body);
457         }
458
459         if (empty_non_text_content_ids != NULL) {
460                 acknowledge_messages (chat, empty_non_text_content_ids);
461                 g_array_free (empty_non_text_content_ids, TRUE);
462         }
463 }
464
465 static void
466 tp_chat_property_flags_changed_cb (TpProxy         *proxy,
467                                    const GPtrArray *properties,
468                                    gpointer         user_data,
469                                    GObject         *chat)
470 {
471         EmpathyTpChatPriv *priv = GET_PRIV (chat);
472         guint              i, j;
473
474         if (priv->channel == NULL)
475                 return;
476
477         if (!priv->had_properties_list || !properties) {
478                 return;
479         }
480
481         for (i = 0; i < properties->len; i++) {
482                 GValueArray    *prop_struct;
483                 TpChatProperty *property;
484                 guint           id;
485                 guint           flags;
486
487                 prop_struct = g_ptr_array_index (properties, i);
488                 id = g_value_get_uint (g_value_array_get_nth (prop_struct, 0));
489                 flags = g_value_get_uint (g_value_array_get_nth (prop_struct, 1));
490
491                 for (j = 0; j < priv->properties->len; j++) {
492                         property = g_ptr_array_index (priv->properties, j);
493                         if (property->id == id) {
494                                 property->flags = flags;
495                                 DEBUG ("property %s flags changed: %d",
496                                         property->name, property->flags);
497                                 break;
498                         }
499                 }
500         }
501 }
502
503 static void
504 tp_chat_properties_changed_cb (TpProxy         *proxy,
505                                const GPtrArray *properties,
506                                gpointer         user_data,
507                                GObject         *chat)
508 {
509         EmpathyTpChatPriv *priv = GET_PRIV (chat);
510         guint              i, j;
511
512         if (priv->channel == NULL)
513                 return;
514
515         if (!priv->had_properties_list || !properties) {
516                 return;
517         }
518
519         for (i = 0; i < properties->len; i++) {
520                 GValueArray    *prop_struct;
521                 TpChatProperty *property;
522                 guint           id;
523                 GValue         *src_value;
524
525                 prop_struct = g_ptr_array_index (properties, i);
526                 id = g_value_get_uint (g_value_array_get_nth (prop_struct, 0));
527                 src_value = g_value_get_boxed (g_value_array_get_nth (prop_struct, 1));
528
529                 for (j = 0; j < priv->properties->len; j++) {
530                         property = g_ptr_array_index (priv->properties, j);
531                         if (property->id == id) {
532                                 if (property->value) {
533                                         g_value_copy (src_value, property->value);
534                                 } else {
535                                         property->value = tp_g_value_slice_dup (src_value);
536                                 }
537
538                                 DEBUG ("property %s changed", property->name);
539                                 g_signal_emit (chat, signals[PROPERTY_CHANGED], 0,
540                                                property->name, property->value);
541                                 break;
542                         }
543                 }
544         }
545 }
546
547 static void
548 tp_chat_get_properties_cb (TpProxy         *proxy,
549                            const GPtrArray *properties,
550                            const GError    *error,
551                            gpointer         user_data,
552                            GObject         *chat)
553 {
554         if (error) {
555                 DEBUG ("Error getting properties: %s", error->message);
556                 return;
557         }
558
559         tp_chat_properties_changed_cb (proxy, properties, user_data, chat);
560 }
561
562 static void
563 tp_chat_list_properties_cb (TpProxy         *proxy,
564                             const GPtrArray *properties,
565                             const GError    *error,
566                             gpointer         user_data,
567                             GObject         *chat)
568 {
569         EmpathyTpChatPriv *priv = GET_PRIV (chat);
570         GArray            *ids;
571         guint              i;
572
573         if (priv->channel == NULL)
574                 return;
575
576         priv->had_properties_list = TRUE;
577
578         if (error) {
579                 DEBUG ("Error listing properties: %s", error->message);
580                 return;
581         }
582
583         ids = g_array_sized_new (FALSE, FALSE, sizeof (guint), properties->len);
584         priv->properties = g_ptr_array_sized_new (properties->len);
585         for (i = 0; i < properties->len; i++) {
586                 GValueArray    *prop_struct;
587                 TpChatProperty *property;
588
589                 prop_struct = g_ptr_array_index (properties, i);
590                 property = g_slice_new0 (TpChatProperty);
591                 property->id = g_value_get_uint (g_value_array_get_nth (prop_struct, 0));
592                 property->name = g_value_dup_string (g_value_array_get_nth (prop_struct, 1));
593                 property->flags = g_value_get_uint (g_value_array_get_nth (prop_struct, 3));
594
595                 DEBUG ("Adding property name=%s id=%d flags=%d",
596                         property->name, property->id, property->flags);
597                 g_ptr_array_add (priv->properties, property);
598                 if (property->flags & TP_PROPERTY_FLAG_READ) {
599                         g_array_append_val (ids, property->id);
600                 }
601         }
602
603         tp_cli_properties_interface_call_get_properties (proxy, -1,
604                                                          ids,
605                                                          tp_chat_get_properties_cb,
606                                                          NULL, NULL,
607                                                          chat);
608
609         g_array_free (ids, TRUE);
610 }
611
612 void
613 empathy_tp_chat_set_property (EmpathyTpChat *chat,
614                               const gchar   *name,
615                               const GValue  *value)
616 {
617         EmpathyTpChatPriv *priv = GET_PRIV (chat);
618         TpChatProperty    *property;
619         guint              i;
620
621         for (i = 0; i < priv->properties->len; i++) {
622                 property = g_ptr_array_index (priv->properties, i);
623                 if (!tp_strdiff (property->name, name)) {
624                         GPtrArray   *properties;
625                         GValueArray *prop;
626                         GValue       id = {0, };
627                         GValue       dest_value = {0, };
628
629                         if (!(property->flags & TP_PROPERTY_FLAG_WRITE)) {
630                                 break;
631                         }
632
633                         g_value_init (&id, G_TYPE_UINT);
634                         g_value_init (&dest_value, G_TYPE_VALUE);
635                         g_value_set_uint (&id, property->id);
636                         g_value_set_boxed (&dest_value, value);
637
638                         prop = g_value_array_new (2);
639                         g_value_array_append (prop, &id);
640                         g_value_array_append (prop, &dest_value);
641
642                         properties = g_ptr_array_sized_new (1);
643                         g_ptr_array_add (properties, prop);
644
645                         DEBUG ("Set property %s", name);
646                         tp_cli_properties_interface_call_set_properties (priv->channel, -1,
647                                                                          properties,
648                                                                          (tp_cli_properties_interface_callback_for_set_properties)
649                                                                          tp_chat_async_cb,
650                                                                          "Seting property", NULL,
651                                                                          G_OBJECT (chat));
652
653                         g_ptr_array_free (properties, TRUE);
654                         g_value_array_free (prop);
655
656                         break;
657                 }
658         }
659 }
660
661 static void
662 tp_chat_dispose (GObject *object)
663 {
664         EmpathyTpChat *self = EMPATHY_TP_CHAT (object);
665         EmpathyTpChatPriv *priv = GET_PRIV (self);
666
667         if (priv->dispose_has_run)
668                 return;
669
670         priv->dispose_has_run = TRUE;
671
672         if (priv->channel != NULL) {
673                 g_signal_handlers_disconnect_by_func (priv->channel,
674                         tp_chat_invalidated_cb, self);
675                 g_object_unref (priv->channel);
676         }
677         priv->channel = NULL;
678
679         if (priv->remote_contact != NULL)
680                 g_object_unref (priv->remote_contact);
681         priv->remote_contact = NULL;
682
683         if (priv->factory != NULL)
684                 g_object_unref (priv->factory);
685         priv->factory = NULL;
686
687         if (priv->user != NULL);
688                 g_object_unref (priv->user);
689         priv->user = NULL;
690
691         if (priv->contact_monitor)
692                 g_object_unref (priv->contact_monitor);
693         priv->contact_monitor = NULL;
694
695         g_queue_foreach (priv->messages_queue, (GFunc) g_object_unref, NULL);
696         g_queue_clear (priv->messages_queue);
697
698         g_queue_foreach (priv->pending_messages_queue,
699                 (GFunc) g_object_unref, NULL);
700         g_queue_clear (priv->pending_messages_queue);
701
702         if (G_OBJECT_CLASS (empathy_tp_chat_parent_class)->dispose)
703                 G_OBJECT_CLASS (empathy_tp_chat_parent_class)->dispose (object);
704 }
705
706 static void
707 tp_chat_finalize (GObject *object)
708 {
709         EmpathyTpChatPriv *priv = GET_PRIV (object);
710         guint              i;
711
712         DEBUG ("Finalize: %p", object);
713
714         if (priv->properties) {
715                 for (i = 0; i < priv->properties->len; i++) {
716                         TpChatProperty *property;
717
718                         property = g_ptr_array_index (priv->properties, i);
719                         g_free (property->name);
720                         if (property->value) {
721                                 tp_g_value_slice_free (property->value);
722                         }
723                         g_slice_free (TpChatProperty, property);
724                 }
725                 g_ptr_array_free (priv->properties, TRUE);
726         }
727
728         g_queue_free (priv->messages_queue);
729         g_queue_free (priv->pending_messages_queue);
730
731         G_OBJECT_CLASS (empathy_tp_chat_parent_class)->finalize (object);
732 }
733
734 static void
735 tp_chat_check_if_ready (EmpathyTpChat *chat)
736 {
737         EmpathyTpChatPriv *priv = GET_PRIV (chat);
738
739         if (priv->ready || priv->user == NULL ||
740             (priv->members == NULL && priv->remote_contact == NULL)) {
741                 return;
742         }
743
744         DEBUG ("Ready!");
745
746         priv->listing_pending_messages = TRUE;
747         tp_cli_channel_type_text_call_list_pending_messages (priv->channel, -1,
748                                                              FALSE,
749                                                              tp_chat_list_pending_messages_cb,
750                                                              NULL, NULL,
751                                                              G_OBJECT (chat));
752
753         tp_cli_channel_type_text_connect_to_received (priv->channel,
754                                                       tp_chat_received_cb,
755                                                       NULL, NULL,
756                                                       G_OBJECT (chat), NULL);
757         tp_cli_channel_type_text_connect_to_sent (priv->channel,
758                                                   tp_chat_sent_cb,
759                                                   NULL, NULL,
760                                                   G_OBJECT (chat), NULL);
761         tp_cli_channel_type_text_connect_to_send_error (priv->channel,
762                                                         tp_chat_send_error_cb,
763                                                         NULL, NULL,
764                                                         G_OBJECT (chat), NULL);
765         tp_cli_channel_interface_chat_state_connect_to_chat_state_changed (priv->channel,
766                                                                            tp_chat_state_changed_cb,
767                                                                            NULL, NULL,
768                                                                            G_OBJECT (chat), NULL);
769         tp_cli_channel_interface_chat_state_connect_to_chat_state_changed (priv->channel,
770                                                                            tp_chat_state_changed_cb,
771                                                                            NULL, NULL,
772                                                                            G_OBJECT (chat), NULL);
773         priv->ready = TRUE;
774         g_object_notify (G_OBJECT (chat), "ready");
775 }
776
777 static void
778 tp_chat_update_remote_contact (EmpathyTpChat *chat)
779 {
780         EmpathyTpChatPriv *priv = GET_PRIV (chat);
781         EmpathyContact *contact = NULL;
782         TpHandle self_handle;
783         TpHandleType handle_type;
784         GList *l;
785
786         /* If this is a named chatroom, never pretend it is a private chat */
787         tp_channel_get_handle (priv->channel, &handle_type);
788         if (handle_type == TP_HANDLE_TYPE_ROOM) {
789                 return;
790         }
791
792         /* This is an MSN-like chat where anyone can join the chat at anytime.
793          * If there is only one non-self contact member, we are in a private
794          * chat and we set the "remote-contact" property to that contact. If
795          * there are more, set the "remote-contact" property to NULL and the
796          * UI will display a contact list. */
797         self_handle = tp_channel_group_get_self_handle (priv->channel);
798         for (l = priv->members; l; l = l->next) {
799                 /* Skip self contact if member */
800                 if (empathy_contact_get_handle (l->data) == self_handle) {
801                         continue;
802                 }
803
804                 /* We have more than one remote contact, break */
805                 if (contact != NULL) {
806                         contact = NULL;
807                         break;
808                 }
809
810                 /* If we didn't find yet a remote contact, keep this one */
811                 contact = l->data;
812         }
813
814         if (priv->remote_contact == contact) {
815                 return;
816         }
817
818         DEBUG ("Changing remote contact from %p to %p",
819                 priv->remote_contact, contact);
820
821         if (priv->remote_contact) {
822                 g_object_unref (priv->remote_contact);
823         }
824
825         priv->remote_contact = contact ? g_object_ref (contact) : NULL;
826         g_object_notify (G_OBJECT (chat), "remote-contact");
827 }
828
829 static void
830 tp_chat_got_added_contacts_cb (EmpathyTpContactFactory *factory,
831                                GList                   *contacts,
832                                gpointer                 user_data,
833                                GObject                 *chat)
834 {
835         EmpathyTpChatPriv *priv = GET_PRIV (chat);
836         GList *l;
837         const TpIntSet *members;
838         TpHandle handle;
839         EmpathyContact *contact;
840
841         members = tp_channel_group_get_members (priv->channel);
842         for (l = contacts; l; l = l->next) {
843                 contact = l->data;
844                 handle = empathy_contact_get_handle (contact);
845
846                 /* Make sure the contact is still member */
847                 if (tp_intset_is_member (members, handle)) {
848                         priv->members = g_list_prepend (priv->members,
849                                 g_object_ref (contact));
850                         g_signal_emit_by_name (chat, "members-changed",
851                                                contact, NULL, 0, NULL, FALSE);
852                 }
853         }
854
855         tp_chat_update_remote_contact (EMPATHY_TP_CHAT (chat));
856         tp_chat_check_if_ready (EMPATHY_TP_CHAT (chat));
857 }
858
859 static void
860 tp_chat_group_members_changed_cb (TpChannel     *self,
861                                   gchar         *message,
862                                   GArray        *added,
863                                   GArray        *removed,
864                                   GArray        *local_pending,
865                                   GArray        *remote_pending,
866                                   guint          actor,
867                                   guint          reason,
868                                   EmpathyTpChat *chat)
869 {
870         EmpathyTpChatPriv *priv = GET_PRIV (chat);
871         EmpathyContact *contact;
872         TpHandle handle;
873         guint i;
874         GList *l;
875
876         /* Remove contacts that are not members anymore */
877         for (i = 0; i < removed->len; i++) {
878                 for (l = priv->members; l; l = l->next) {
879                         contact = l->data;
880                         handle = empathy_contact_get_handle (contact);
881                         if (handle == g_array_index (removed, TpHandle, i)) {
882                                 priv->members = g_list_delete_link (priv->members, l);
883                                 g_signal_emit_by_name (chat, "members-changed",
884                                                        contact, actor, reason,
885                                                        message, FALSE);
886                                 g_object_unref (contact);
887                                 break;
888                         }
889                 }
890         }
891
892         /* Request added contacts */
893         if (added->len > 0) {
894                 empathy_tp_contact_factory_get_from_handles (priv->factory,
895                         added->len, (TpHandle*) added->data,
896                         tp_chat_got_added_contacts_cb, NULL, NULL,
897                         G_OBJECT (chat));
898         }
899
900         tp_chat_update_remote_contact (chat);
901 }
902
903 static void
904 tp_chat_got_remote_contact_cb (EmpathyTpContactFactory *factory,
905                                GList *contacts,
906                                gpointer user_data,
907                                GObject *chat)
908 {
909         EmpathyTpChatPriv *priv = GET_PRIV (chat);
910
911         priv->remote_contact = g_object_ref (contacts->data);
912         g_object_notify (chat, "remote-contact");
913
914         tp_chat_check_if_ready (EMPATHY_TP_CHAT (chat));
915 }
916
917 static void
918 tp_chat_got_self_contact_cb (EmpathyTpContactFactory *factory,
919                              GList                   *contacts,
920                              gpointer                 user_data,
921                              GObject                 *chat)
922 {
923         EmpathyTpChatPriv *priv = GET_PRIV (chat);
924
925         priv->user = g_object_ref (contacts->data);
926         empathy_contact_set_is_user (priv->user, TRUE);
927         tp_chat_check_if_ready (EMPATHY_TP_CHAT (chat));
928 }
929
930 static void
931 tp_chat_get_self_handle_cb (TpConnection *connection,
932                             TpHandle self_handle,
933                             const GError *error,
934                             gpointer user_data,
935                             GObject *chat)
936 {
937         EmpathyTpChatPriv *priv = GET_PRIV (chat);
938
939         if (error) {
940                 DEBUG ("Error: %s", error->message);
941                 tp_cli_channel_call_close (priv->channel, -1,
942                                            NULL, NULL, NULL, NULL);
943                 return;
944         }
945
946         empathy_tp_contact_factory_get_from_handles (priv->factory,
947                 1, &self_handle,
948                 tp_chat_got_self_contact_cb,
949                 NULL, NULL, chat);
950 }
951
952 static GObject *
953 tp_chat_constructor (GType                  type,
954                      guint                  n_props,
955                      GObjectConstructParam *props)
956 {
957         GObject           *chat;
958         EmpathyTpChatPriv *priv;
959         TpConnection      *connection;
960         TpHandle           handle;
961
962         chat = G_OBJECT_CLASS (empathy_tp_chat_parent_class)->constructor (type, n_props, props);
963
964         priv = GET_PRIV (chat);
965
966         connection = tp_channel_borrow_connection (priv->channel);
967         priv->factory = empathy_tp_contact_factory_dup_singleton (connection);
968         g_signal_connect (priv->channel, "invalidated",
969                           G_CALLBACK (tp_chat_invalidated_cb),
970                           chat);
971
972         if (tp_proxy_has_interface_by_id (priv->channel,
973                                           TP_IFACE_QUARK_CHANNEL_INTERFACE_GROUP)) {
974                 const TpIntSet *members;
975                 GArray *handles;
976
977                 /* Get self contact from the group's self handle */
978                 handle = tp_channel_group_get_self_handle (priv->channel);
979                 empathy_tp_contact_factory_get_from_handles (priv->factory,
980                         1, &handle,
981                         tp_chat_got_self_contact_cb,
982                         NULL, NULL, chat);
983
984                 /* Get initial member contacts */
985                 members = tp_channel_group_get_members (priv->channel);
986                 handles = tp_intset_to_array (members);         
987                 empathy_tp_contact_factory_get_from_handles (priv->factory,
988                         handles->len, (TpHandle*) handles->data,
989                         tp_chat_got_added_contacts_cb, NULL, NULL, chat);
990
991                 g_signal_connect_swapped (priv->channel, "group-members-changed",
992                         G_CALLBACK (tp_chat_group_members_changed_cb), chat);
993         } else {
994                 /* Get the self contact from the connection's self handle */
995                 tp_cli_connection_call_get_self_handle (connection, -1,
996                         tp_chat_get_self_handle_cb, NULL, NULL, chat);
997
998                 /* Get the remote contact */
999                 handle = tp_channel_get_handle (priv->channel, NULL);
1000                 empathy_tp_contact_factory_get_from_handles (priv->factory,
1001                         1, &handle, tp_chat_got_remote_contact_cb,
1002                         NULL, NULL, chat);
1003         }
1004
1005         if (tp_proxy_has_interface_by_id (priv->channel,
1006                                           TP_IFACE_QUARK_PROPERTIES_INTERFACE)) {
1007                 tp_cli_properties_interface_call_list_properties (priv->channel, -1,
1008                                                                   tp_chat_list_properties_cb,
1009                                                                   NULL, NULL,
1010                                                                   G_OBJECT (chat));
1011                 tp_cli_properties_interface_connect_to_properties_changed (priv->channel,
1012                                                                            tp_chat_properties_changed_cb,
1013                                                                            NULL, NULL,
1014                                                                            G_OBJECT (chat), NULL);
1015                 tp_cli_properties_interface_connect_to_property_flags_changed (priv->channel,
1016                                                                                tp_chat_property_flags_changed_cb,
1017                                                                                NULL, NULL,
1018                                                                                G_OBJECT (chat), NULL);
1019         }
1020
1021         return chat;
1022 }
1023
1024 static void
1025 tp_chat_get_property (GObject    *object,
1026                       guint       param_id,
1027                       GValue     *value,
1028                       GParamSpec *pspec)
1029 {
1030         EmpathyTpChatPriv *priv = GET_PRIV (object);
1031
1032         switch (param_id) {
1033         case PROP_CHANNEL:
1034                 g_value_set_object (value, priv->channel);
1035                 break;
1036         case PROP_REMOTE_CONTACT:
1037                 g_value_set_object (value, priv->remote_contact);
1038                 break;
1039         case PROP_READY:
1040                 g_value_set_boolean (value, priv->ready);
1041                 break;
1042         default:
1043                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1044                 break;
1045         };
1046 }
1047
1048 static void
1049 tp_chat_set_property (GObject      *object,
1050                       guint         param_id,
1051                       const GValue *value,
1052                       GParamSpec   *pspec)
1053 {
1054         EmpathyTpChatPriv *priv = GET_PRIV (object);
1055
1056         switch (param_id) {
1057         case PROP_CHANNEL:
1058                 priv->channel = g_value_dup_object (value);
1059                 break;
1060         default:
1061                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1062                 break;
1063         };
1064 }
1065
1066 static void
1067 empathy_tp_chat_class_init (EmpathyTpChatClass *klass)
1068 {
1069         GObjectClass *object_class = G_OBJECT_CLASS (klass);
1070
1071         object_class->dispose = tp_chat_dispose;
1072         object_class->finalize = tp_chat_finalize;
1073         object_class->constructor = tp_chat_constructor;
1074         object_class->get_property = tp_chat_get_property;
1075         object_class->set_property = tp_chat_set_property;
1076
1077         g_object_class_install_property (object_class,
1078                                          PROP_CHANNEL,
1079                                          g_param_spec_object ("channel",
1080                                                               "telepathy channel",
1081                                                               "The text channel for the chat",
1082                                                               TP_TYPE_CHANNEL,
1083                                                               G_PARAM_READWRITE |
1084                                                               G_PARAM_CONSTRUCT_ONLY));
1085
1086         g_object_class_install_property (object_class,
1087                                          PROP_REMOTE_CONTACT,
1088                                          g_param_spec_object ("remote-contact",
1089                                                               "The remote contact",
1090                                                               "The remote contact if there is no group iface on the channel",
1091                                                               EMPATHY_TYPE_CONTACT,
1092                                                               G_PARAM_READABLE));
1093
1094         g_object_class_install_property (object_class,
1095                                          PROP_READY,
1096                                          g_param_spec_boolean ("ready",
1097                                                                "Is the object ready",
1098                                                                "This object can't be used until this becomes true",
1099                                                                FALSE,
1100                                                                G_PARAM_READABLE));
1101
1102         /* Signals */
1103         signals[MESSAGE_RECEIVED] =
1104                 g_signal_new ("message-received",
1105                               G_TYPE_FROM_CLASS (klass),
1106                               G_SIGNAL_RUN_LAST,
1107                               0,
1108                               NULL, NULL,
1109                               g_cclosure_marshal_VOID__OBJECT,
1110                               G_TYPE_NONE,
1111                               1, EMPATHY_TYPE_MESSAGE);
1112
1113         signals[SEND_ERROR] =
1114                 g_signal_new ("send-error",
1115                               G_TYPE_FROM_CLASS (klass),
1116                               G_SIGNAL_RUN_LAST,
1117                               0,
1118                               NULL, NULL,
1119                               _empathy_marshal_VOID__OBJECT_UINT,
1120                               G_TYPE_NONE,
1121                               2, EMPATHY_TYPE_MESSAGE, G_TYPE_UINT);
1122
1123         signals[CHAT_STATE_CHANGED] =
1124                 g_signal_new ("chat-state-changed",
1125                               G_TYPE_FROM_CLASS (klass),
1126                               G_SIGNAL_RUN_LAST,
1127                               0,
1128                               NULL, NULL,
1129                               _empathy_marshal_VOID__OBJECT_UINT,
1130                               G_TYPE_NONE,
1131                               2, EMPATHY_TYPE_CONTACT, G_TYPE_UINT);
1132
1133         signals[PROPERTY_CHANGED] =
1134                 g_signal_new ("property-changed",
1135                               G_TYPE_FROM_CLASS (klass),
1136                               G_SIGNAL_RUN_LAST,
1137                               0,
1138                               NULL, NULL,
1139                               _empathy_marshal_VOID__STRING_BOXED,
1140                               G_TYPE_NONE,
1141                               2, G_TYPE_STRING, G_TYPE_VALUE);
1142
1143         signals[DESTROY] =
1144                 g_signal_new ("destroy",
1145                               G_TYPE_FROM_CLASS (klass),
1146                               G_SIGNAL_RUN_LAST,
1147                               0,
1148                               NULL, NULL,
1149                               g_cclosure_marshal_VOID__VOID,
1150                               G_TYPE_NONE,
1151                               0);
1152
1153         g_type_class_add_private (object_class, sizeof (EmpathyTpChatPriv));
1154 }
1155
1156 static void
1157 empathy_tp_chat_init (EmpathyTpChat *chat)
1158 {
1159         EmpathyTpChatPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chat,
1160                 EMPATHY_TYPE_TP_CHAT, EmpathyTpChatPriv);
1161
1162         chat->priv = priv;
1163         priv->contact_monitor = NULL;
1164         priv->messages_queue = g_queue_new ();
1165         priv->pending_messages_queue = g_queue_new ();
1166 }
1167
1168 static void
1169 tp_chat_iface_init (EmpathyContactListIface *iface)
1170 {
1171         iface->add         = tp_chat_add;
1172         iface->remove      = tp_chat_remove;
1173         iface->get_members = tp_chat_get_members;
1174         iface->get_monitor = tp_chat_get_monitor;
1175 }
1176
1177 EmpathyTpChat *
1178 empathy_tp_chat_new (TpChannel *channel)
1179 {
1180         return g_object_new (EMPATHY_TYPE_TP_CHAT,
1181                              "channel", channel,
1182                              NULL);
1183 }
1184
1185 void
1186 empathy_tp_chat_close (EmpathyTpChat *chat) {
1187         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1188
1189         /* If there are still messages left, it'll come back..
1190            We loose the ordering of sent messages though */
1191         g_signal_handlers_disconnect_by_func (priv->channel,
1192                 tp_chat_invalidated_cb, chat);
1193
1194         tp_cli_channel_call_close (priv->channel, -1, tp_chat_async_cb,
1195                 "closing channel", NULL, NULL);
1196
1197         g_object_unref (priv->channel);
1198         priv->channel = NULL;
1199
1200         g_signal_emit (chat, signals[DESTROY], 0);
1201 }
1202
1203 const gchar *
1204 empathy_tp_chat_get_id (EmpathyTpChat *chat)
1205 {
1206         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1207
1208         g_return_val_if_fail (EMPATHY_IS_TP_CHAT (chat), NULL);
1209
1210         return tp_channel_get_identifier (priv->channel);
1211 }
1212
1213 EmpathyContact *
1214 empathy_tp_chat_get_remote_contact (EmpathyTpChat *chat)
1215 {
1216         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1217
1218         g_return_val_if_fail (EMPATHY_IS_TP_CHAT (chat), NULL);
1219         g_return_val_if_fail (priv->ready, NULL);
1220
1221         return priv->remote_contact;
1222 }
1223
1224 TpChannel *
1225 empathy_tp_chat_get_channel (EmpathyTpChat *chat)
1226 {
1227         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1228
1229         g_return_val_if_fail (EMPATHY_IS_TP_CHAT (chat), NULL);
1230
1231         return priv->channel;
1232 }
1233
1234 TpConnection *
1235 empathy_tp_chat_get_connection (EmpathyTpChat *chat)
1236 {
1237         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1238
1239         g_return_val_if_fail (EMPATHY_IS_TP_CHAT (chat), NULL);
1240
1241         return tp_channel_borrow_connection (priv->channel);
1242 }
1243
1244 gboolean
1245 empathy_tp_chat_is_ready (EmpathyTpChat *chat)
1246 {
1247         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1248
1249         g_return_val_if_fail (EMPATHY_IS_TP_CHAT (chat), FALSE);
1250
1251         return priv->ready;
1252 }
1253
1254 void
1255 empathy_tp_chat_send (EmpathyTpChat *chat,
1256                       EmpathyMessage *message)
1257 {
1258         EmpathyTpChatPriv        *priv = GET_PRIV (chat);
1259         const gchar              *message_body;
1260         TpChannelTextMessageType  message_type;
1261
1262         g_return_if_fail (EMPATHY_IS_TP_CHAT (chat));
1263         g_return_if_fail (EMPATHY_IS_MESSAGE (message));
1264         g_return_if_fail (priv->ready);
1265
1266         message_body = empathy_message_get_body (message);
1267         message_type = empathy_message_get_tptype (message);
1268
1269         DEBUG ("Sending message: %s", message_body);
1270         tp_cli_channel_type_text_call_send (priv->channel, -1,
1271                                             message_type,
1272                                             message_body,
1273                                             tp_chat_send_cb,
1274                                             g_object_ref (message),
1275                                             (GDestroyNotify) g_object_unref,
1276                                             G_OBJECT (chat));
1277 }
1278
1279 void
1280 empathy_tp_chat_set_state (EmpathyTpChat      *chat,
1281                            TpChannelChatState  state)
1282 {
1283         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1284
1285         g_return_if_fail (EMPATHY_IS_TP_CHAT (chat));
1286         g_return_if_fail (priv->ready);
1287
1288         DEBUG ("Set state: %d", state);
1289         tp_cli_channel_interface_chat_state_call_set_chat_state (priv->channel, -1,
1290                                                                  state,
1291                                                                  tp_chat_async_cb,
1292                                                                  "setting chat state",
1293                                                                  NULL,
1294                                                                  G_OBJECT (chat));
1295 }
1296
1297
1298 const GList *
1299 empathy_tp_chat_get_pending_messages (EmpathyTpChat *chat)
1300 {
1301         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1302
1303         g_return_val_if_fail (EMPATHY_IS_TP_CHAT (chat), NULL);
1304         g_return_val_if_fail (priv->ready, NULL);
1305
1306         return priv->pending_messages_queue->head;
1307 }
1308
1309 static void
1310 acknowledge_messages (EmpathyTpChat *chat, GArray *ids) {
1311         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1312
1313         tp_cli_channel_type_text_call_acknowledge_pending_messages (
1314                 priv->channel, -1, ids, tp_chat_async_cb,
1315                 "acknowledging received message", NULL, G_OBJECT (chat));
1316 }
1317
1318 void
1319 empathy_tp_chat_acknowledge_message (EmpathyTpChat *chat,
1320                                      EmpathyMessage *message) {
1321         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1322         GArray *message_ids;
1323         GList *m;
1324         guint id;
1325
1326         g_return_if_fail (EMPATHY_IS_TP_CHAT (chat));
1327         g_return_if_fail (priv->ready);
1328
1329         if (empathy_message_get_sender (message) == priv->user)
1330                 goto out;
1331
1332         message_ids = g_array_sized_new (FALSE, FALSE, sizeof (guint), 1);
1333
1334         id = empathy_message_get_id (message);
1335         g_array_append_val (message_ids, id);
1336         acknowledge_messages (chat, message_ids);
1337         g_array_free (message_ids, TRUE);
1338
1339 out:
1340         m = g_queue_find (priv->pending_messages_queue, message);
1341         g_assert (m != NULL);
1342         g_queue_delete_link (priv->pending_messages_queue, m);
1343         g_object_unref (message);
1344 }
1345
1346 void
1347 empathy_tp_chat_acknowledge_messages (EmpathyTpChat *chat,
1348                                       const GList *messages) {
1349         EmpathyTpChatPriv *priv = GET_PRIV (chat);
1350         /* Copy messages as the messges list (probably is) our own */
1351         GList *msgs = g_list_copy ((GList *) messages);
1352         GList *l;
1353         guint length;
1354         GArray *message_ids;
1355
1356         g_return_if_fail (EMPATHY_IS_TP_CHAT (chat));
1357         g_return_if_fail (priv->ready);
1358
1359         length = g_list_length ((GList *)messages);
1360
1361         if (length == 0)
1362                 return;
1363
1364         message_ids = g_array_sized_new (FALSE, FALSE, sizeof (guint), length);
1365
1366         for (l = msgs; l != NULL; l = g_list_next (l)) {
1367                 GList *m;
1368
1369                 EmpathyMessage *message = EMPATHY_MESSAGE (l->data);
1370
1371                 m = g_queue_find (priv->pending_messages_queue, message);
1372                 g_assert (m != NULL);
1373                 g_queue_delete_link (priv->pending_messages_queue, m);
1374
1375                 if (empathy_message_get_sender (message) != priv->user) {
1376                         guint id = empathy_message_get_id (message);
1377                         g_array_append_val (message_ids, id);
1378                 }
1379                 g_object_unref (message);
1380         }
1381
1382         if (message_ids->len > 0)
1383                 acknowledge_messages (chat, message_ids);
1384
1385         g_array_free (message_ids, TRUE);
1386         g_list_free (msgs);
1387 }
1388