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