Fixes NB#113634, show progress information in Viewer when opening large attachments
[modest] / libmodest-dbus-client / libmodest-dbus-client.c
1 /* Copyright (c) 2007, Nokia Corporation
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  * * Redistributions of source code must retain the above copyright
9  *   notice, this list of conditions and the following disclaimer.
10  * * Redistributions in binary form must reproduce the above copyright
11  *   notice, this list of conditions and the following disclaimer in the
12  *   documentation and/or other materials provided with the distribution.
13  * * Neither the name of the Nokia Corporation nor the names of its
14  *   contributors may be used to endorse or promote products derived from
15  *   this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "libmodest-dbus-client.h"
31 #include <dbus_api/modest-dbus-api.h> /* For the API strings. */
32
33 //#define DBUS_API_SUBJECT_TO_CHANGE 1
34 #include <dbus/dbus.h>
35 #include <dbus/dbus-glib-lowlevel.h>
36 #include <string.h>
37
38
39
40 /** Get a comma-separated list of attachement URI strings, 
41  * from a list of strings.
42  */
43 static gchar* get_attachments_string (GSList *attachments)
44 {
45         if (!attachments)
46                 return NULL;
47                 
48         gchar *attachments_str = g_strdup("");
49         
50         GSList *iter = attachments;
51         while (iter)
52         {
53                 if (iter->data) {
54                         gchar *tmp = g_strconcat(attachments_str, ",", (gchar *) (iter->data), NULL);
55                         g_free(attachments_str);
56                         attachments_str = tmp;
57                 }
58                 
59                 iter = g_slist_next(iter);
60         }
61         
62         return attachments_str;
63 }
64         
65 /**
66  * libmodest_dbus_client_mail_to:
67  * @osso_context: a valid #osso_context_t object.
68  * @mailto_uri: A mailto URI.
69  * 
70  * This function will try to do a remote procedure call (rpc)
71  * into modest (or start it if necessary) and open a composer
72  * window with the supplied parameters prefilled.
73  *
74  * Return value: Whether or not the rpc call to modest
75  * was successfull
76  **/
77 gboolean 
78 libmodest_dbus_client_mail_to (osso_context_t *osso_context, const gchar *mailto_uri)
79 {
80         osso_rpc_t retval;
81         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context, 
82                    MODEST_DBUS_NAME, 
83                    MODEST_DBUS_METHOD_MAIL_TO, &retval, 
84                    DBUS_TYPE_STRING, mailto_uri, 
85                    DBUS_TYPE_INVALID);
86                 
87         if (ret != OSSO_OK) {
88                 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
89                 return FALSE;
90         } else {
91                 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
92         }
93         
94         osso_rpc_free_val(&retval);
95         
96         return TRUE;
97 }
98
99 /**
100  * libmodest_dbus_client_compose_mail:
101  * @osso_context: a valid #osso_context_t object.
102  * @to: The Recipients (From: line)
103  * @cc: Recipients for carbon copies
104  * @bcc: Recipients for blind carbon copies
105  * @subject: Subject line
106  * @body: The actual body of the mail to compose.
107  * @attachments: Additional list of attachments. A list of URI strings.
108  * 
109  * This function will try to do a remote procedure call (rpc)
110  * into modest (or start it if necessary) and open a composer
111  * window with the supplied parameters prefilled.
112  *
113  * Return value: Whether or not the rpc call to modest
114  * was successfull
115  **/
116 gboolean
117 libmodest_dbus_client_compose_mail (osso_context_t *osso_context, const gchar *to, const gchar *cc, 
118         const gchar *bcc, const gchar* subject, const gchar* body, GSList *attachments)
119 {
120         osso_rpc_t retval;
121
122         gchar *attachments_str = get_attachments_string(attachments);
123
124         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
125                    MODEST_DBUS_NAME, 
126                    MODEST_DBUS_METHOD_COMPOSE_MAIL, &retval, 
127                    DBUS_TYPE_STRING, to, 
128                    DBUS_TYPE_STRING, cc, 
129                    DBUS_TYPE_STRING, bcc, 
130                    DBUS_TYPE_STRING, subject, 
131                    DBUS_TYPE_STRING, body,
132                    DBUS_TYPE_STRING, attachments_str,
133                    DBUS_TYPE_INVALID);
134
135         g_free (attachments_str);
136
137         if (ret != OSSO_OK) {
138                 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
139                 return FALSE;
140         } else {
141                 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
142         }
143
144         osso_rpc_free_val(&retval);
145
146
147         return TRUE;
148 }
149
150 /**
151  * libmodest_dbus_client_open_message:
152  * @osso_context: a valid #osso_context_t object.
153  * @msg_uri: A valid url to a mail
154  *
155  * This method will try to find the message supplied
156  * by @msg_uri and open it for display if found. 
157  * It will use remote procedure calls (rpc) over 
158  * dbus to do so.
159  *  
160  * Return value: TRUE on successs, FALSE on error
161  **/
162 gboolean 
163 libmodest_dbus_client_open_message (osso_context_t *osso_context, const gchar *mail_uri)
164 {
165         osso_rpc_t retval;
166         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context, 
167                    MODEST_DBUS_NAME, 
168                    MODEST_DBUS_METHOD_OPEN_MESSAGE, &retval, 
169                    DBUS_TYPE_STRING, mail_uri, 
170                    DBUS_TYPE_INVALID);
171                 
172         if (ret != OSSO_OK) {
173                 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
174                 return FALSE;
175         } else {
176                 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
177         }
178         
179         osso_rpc_free_val(&retval);
180         
181         return TRUE;
182 }
183
184 gboolean 
185 libmodest_dbus_client_send_and_receive (osso_context_t *osso_context)
186 {
187         osso_rpc_t retval;
188         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context, 
189                    MODEST_DBUS_NAME, 
190                    MODEST_DBUS_METHOD_SEND_RECEIVE, &retval, 
191                    DBUS_TYPE_INVALID);
192                 
193         if (ret != OSSO_OK) {
194                 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
195                 return FALSE;
196         } else {
197                 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
198         }
199         
200         osso_rpc_free_val(&retval);
201         
202         return TRUE;
203 }
204
205 gboolean 
206 libmodest_dbus_client_open_default_inbox (osso_context_t *osso_context)
207 {
208         osso_rpc_t retval;
209         const osso_return_t ret = osso_rpc_run_with_defaults(osso_context, 
210                    MODEST_DBUS_NAME, 
211                    MODEST_DBUS_METHOD_OPEN_DEFAULT_INBOX, &retval, 
212                    DBUS_TYPE_INVALID);
213                 
214         if (ret != OSSO_OK) {
215                 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
216                 return FALSE;
217         } else {
218                 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
219         }
220         
221         osso_rpc_free_val(&retval);
222         
223         return TRUE;
224 }
225
226 gboolean
227 libmodest_dbus_client_open_account (osso_context_t *osso_context,
228                                     const gchar *account_id)
229 {
230         osso_rpc_t retval;
231         const osso_return_t ret =
232                 osso_rpc_run_with_defaults(osso_context,
233                                            MODEST_DBUS_NAME,
234                                            MODEST_DBUS_METHOD_OPEN_ACCOUNT, &retval,
235                                            DBUS_TYPE_STRING, account_id,
236                                            DBUS_TYPE_INVALID);
237
238         if (ret != OSSO_OK) {
239                 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
240                 return FALSE;
241         } else {
242                 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
243         }
244
245         osso_rpc_free_val(&retval);
246
247         return TRUE;
248 }
249
250 /**
251  * libmodest_dbus_client_delete_message:
252  * @osso_context: a valid #osso_context_t object.
253  * @msg_uri: A valid url to a mail 
254  *
255  * This method will try to find the message supplied
256  * by @msg_uri and if found delete it. It will use
257  * remote procedure calls (rpc) over dbus to do so.
258  * 
259  * Return value: TRUE on successs, FALSE on error
260  **/
261 gboolean
262 libmodest_dbus_client_delete_message (osso_context_t   *osso_ctx,
263                                       const char       *msg_uri)
264 {
265         osso_rpc_t    retval;
266         osso_return_t ret;
267        
268         ret = osso_rpc_run_with_defaults (osso_ctx, 
269                                           MODEST_DBUS_NAME, 
270                                           MODEST_DBUS_METHOD_DELETE_MESSAGE, &retval, 
271                                           DBUS_TYPE_STRING, msg_uri, 
272                                           DBUS_TYPE_INVALID);
273                 
274         if (ret != OSSO_OK) {
275                 g_debug ("debug: osso_rpc_run() failed.\n");
276         } else {
277                 g_debug ("debug: osso_rpc_run() succeeded.\n");
278         }
279         
280         osso_rpc_free_val (&retval);
281
282         return ret == OSSO_OK;
283 }
284
285 static void
286 modest_search_hit_free (ModestSearchHit *hit)
287 {
288         g_free (hit->msgid);
289         g_slice_free (ModestSearchHit, hit);
290 }
291
292 void
293 modest_search_hit_list_free (GList *hits)
294 {
295         GList *iter;
296
297         if (hits == NULL) {
298                 return;
299         }
300
301         for (iter = hits; iter; iter = iter->next) {
302                 modest_search_hit_free ((ModestSearchHit *) iter->data);
303         }
304
305         g_list_free (hits);
306 }
307
308 static char *
309 _dbus_iter_get_string_or_null (DBusMessageIter *iter)
310 {
311         const char *string = NULL;
312         char       *ret = NULL;
313
314         dbus_message_iter_get_basic (iter, &string);
315         
316         if (string && strlen (string)) {
317                 ret = g_strdup (string);
318         }
319
320         return ret;
321 }
322
323 static guint64
324 _dbus_iter_get_uint64 (DBusMessageIter *iter)
325 {
326         dbus_uint64_t ui64v;
327         guint64       ret;
328
329         ui64v = 0;
330         dbus_message_iter_get_basic (iter, &ui64v);
331
332         ret = (guint64) ui64v;
333
334         return ret;
335 }
336
337
338 static gint64
339 _dbus_iter_get_int64 (DBusMessageIter *iter)
340 {
341         dbus_int64_t i64v;
342         gint64       ret;
343
344         i64v = 0;
345         dbus_message_iter_get_basic (iter, &i64v);
346
347         ret = (gint64) i64v;
348
349         return ret;
350 }
351
352 static gboolean
353 _dbus_iter_get_boolean (DBusMessageIter *iter)
354
355 {
356         dbus_bool_t  val;
357         gboolean     ret;
358
359         val = FALSE;
360         dbus_message_iter_get_basic (iter, &val);
361
362         ret = (gboolean) val;
363
364         return ret;
365 }
366
367 /** Get the values from the complex type (SEARCH_HIT_DBUS_TYPE)
368  * in the D-Bus return message. */
369 static ModestSearchHit *
370 modest_dbus_message_iter_get_search_hit (DBusMessageIter *parent)
371 {
372         ModestSearchHit *hit;
373         DBusMessageIter  child;
374         dbus_bool_t      res;
375         int              arg_type;
376         gboolean         error;
377
378         error = FALSE;
379         hit = g_slice_new0 (ModestSearchHit);
380
381         arg_type = dbus_message_iter_get_arg_type (parent);
382
383         if (arg_type != 'r') {
384                 return NULL;
385         }
386
387         dbus_message_iter_recurse (parent, &child);
388         
389         /* msgid  */
390         arg_type = dbus_message_iter_get_arg_type (&child);
391
392         if (arg_type != DBUS_TYPE_STRING) {
393                 error = TRUE;
394                 goto out;
395         }
396
397         hit->msgid = _dbus_iter_get_string_or_null (&child);
398
399         res = dbus_message_iter_next (&child);
400         if (res == FALSE) {
401                 error = TRUE;
402                 goto out;
403         }
404
405         /* subject  */
406         arg_type = dbus_message_iter_get_arg_type (&child);
407
408         if (arg_type != DBUS_TYPE_STRING) {
409                 error = TRUE;
410                 goto out;
411         }
412
413         hit->subject = _dbus_iter_get_string_or_null (&child);
414
415         res = dbus_message_iter_next (&child);
416         if (res == FALSE) {
417                 error = TRUE;
418                 goto out;
419         }
420
421         /* folder  */
422         arg_type = dbus_message_iter_get_arg_type (&child);
423
424         if (arg_type != DBUS_TYPE_STRING) {
425                 error = TRUE;
426                 goto out;
427         }
428
429         hit->folder = _dbus_iter_get_string_or_null (&child);
430
431         res = dbus_message_iter_next (&child);
432         if (res == FALSE) {
433                 error = TRUE;
434                 goto out;
435         }
436
437         /* sender  */
438         arg_type = dbus_message_iter_get_arg_type (&child);
439
440         if (arg_type != DBUS_TYPE_STRING) {
441                 error = TRUE;
442                 goto out;
443         }
444
445         hit->sender = _dbus_iter_get_string_or_null (&child);
446
447         res = dbus_message_iter_next (&child);
448         if (res == FALSE) {
449                 error = TRUE;
450                 goto out;
451         }
452
453         /* msize  */
454         arg_type = dbus_message_iter_get_arg_type (&child);
455
456         if (arg_type != DBUS_TYPE_UINT64) {
457                 error = TRUE;
458                 goto out;
459         }
460
461         hit->msize = _dbus_iter_get_uint64 (&child);
462
463         res = dbus_message_iter_next (&child);
464         if (res == FALSE) {
465                 error = TRUE;
466                 goto out;
467         }
468
469         /* has_attachment  */
470         arg_type = dbus_message_iter_get_arg_type (&child);
471
472         if (arg_type != DBUS_TYPE_BOOLEAN) {
473                 error = TRUE;
474                 goto out;
475         }
476
477         hit->has_attachment = _dbus_iter_get_boolean (&child); 
478
479         res = dbus_message_iter_next (&child);
480         if (res == FALSE) {
481                 error = TRUE;
482                 goto out;
483         }
484
485         /* is_unread  */
486         arg_type = dbus_message_iter_get_arg_type (&child);
487
488         if (arg_type != DBUS_TYPE_BOOLEAN) {
489                 error = TRUE;
490                 goto out;
491         }
492
493         hit->is_unread = _dbus_iter_get_boolean (&child);  
494
495         res = dbus_message_iter_next (&child);
496         if (res == FALSE) {
497                 error = TRUE;
498                 goto out;
499         }
500
501         /* timestamp  */
502         arg_type = dbus_message_iter_get_arg_type (&child);
503
504         if (arg_type != DBUS_TYPE_INT64) {
505                 error = TRUE;
506                 goto out;
507         }
508
509         hit->timestamp = _dbus_iter_get_int64 (&child); 
510
511         res = dbus_message_iter_next (&child);
512         if (res == TRUE) {
513                 error = TRUE;
514                 goto out;
515         }       
516
517 out:
518         if (error) {
519                 g_warning ("%s: Error during unmarshalling", __FUNCTION__);
520                 modest_search_hit_free (hit);
521                 hit = NULL;
522         }
523
524         return hit;
525 }
526
527 /**
528  * libmodest_dbus_client_search:
529  * @osso_ctx: A valid #osso_context_t object.
530  * @query: The term to search for.
531  * @folder: An url to specific folder or %NULL to search everywhere.
532  * @start_date: Search hits before this date will be ignored.
533  * @end_date: Search hits after this date will be ignored.
534  * @min_size: Messagers smaller then this size will be ingored.
535  * @flags: A list of flags where to search so the documentation 
536  * of %ModestDBusSearchFlags for details.
537  * @hits: A pointer to a valid GList pointer that will contain the search
538  * hits (ModestSearchHit). The list and the items must be freed by the caller 
539  * with modest_search_hit_list_free().
540  *
541  * This method will search the folder specified by a valid url in @folder or all
542  * known accounts (local and remote) if %NULL for matches of the search term(s)
543  * specified in @query. It is legal to specify 0 in @start_date, @end_date and
544  * @min_size to ignore these parameters during the search otherwise those message
545  * that do not meet the specifed dates or size will be ignored.
546  * Where to search, be it subject, sender or the whole body can be specified by
547  * the @flags parameter.
548  *
549  * Upon success TRUE is returned and @hits will include the search hits or the list
550  * migh be empty if none of the messages matched the search criteria. The returned
551  * list must be freed with modest_search_hit_list_free (). It is save to pass
552  * %NULL to this function so you can call this function on the result list no matter
553  * if a hit was found or not (means the list is empty - i.e. %NULL)
554  * FALSE will only be return if an error during the remote procedure call (rpc) 
555  * occured or if the specified folder could not be found.
556  *
557  * NOTE: The body of a message can only be searched if it was previously downloaded by
558  * modest. This function does also not attempt do to remote searches (i.e. IMAP search).
559  *
560  * Example to search every account for message containing "no":
561  * <informalexample><programlisting>
562  * ModestDBusSearchFlags  flags;
563  * osso_context_t        *osso_context;
564  * GList                 *hits;
565  * GList                 *iter;
566  * gboolean               res;
567  * 
568  * [...] Initialize osso context [...]
569  *
570  * res = libmodest_dbus_client_search (osso_context,
571  *                                     "no",
572  *                                     NULL,
573  *                                     0,
574  *                                     0,
575  *                                     0,
576  *                                     flags,
577  *                                     &hits);
578  * 
579  * for (iter = hits; iter; iter = iter->next) {
580  *      ModestSearchHit *hit = (ModestSearchHit *) iter->data;
581  *      
582  *      [...] Do something with the hit [...]
583  *
584  *      }
585  *
586  *      modest_search_hit_list_free (hits);
587  * </programlisting></informalexample>
588  * 
589  * Return value: TRUE if the search succeded or FALSE for an error during the search
590  **/
591 gboolean
592 libmodest_dbus_client_search (osso_context_t          *osso_ctx,
593                               const gchar             *query,
594                               const gchar             *folder,
595                               time_t                   start_date,
596                               time_t                   end_date,
597                               guint32                  min_size,
598                               ModestDBusSearchFlags    flags,
599                               GList                  **hits)
600 {
601
602         DBusMessage *msg;
603         dbus_bool_t res;
604         DBusConnection *con;
605         DBusMessageIter iter;
606         DBusMessageIter child;
607         DBusMessage *reply = NULL;
608         gint timeout;
609         int arg_type;
610         dbus_int64_t sd_v;
611         dbus_int64_t ed_v;
612         dbus_int32_t flags_v;
613         dbus_uint32_t size_v;
614
615         if (query == NULL) {
616                 return FALSE;
617         }
618
619         con = osso_get_dbus_connection (osso_ctx);
620
621         if (con == NULL) {
622                 g_warning ("Could not get dbus connection\n");
623                 return FALSE;
624
625         }
626
627
628         msg = dbus_message_new_method_call (MODEST_DBUS_SERVICE,
629                 MODEST_DBUS_OBJECT,
630                 MODEST_DBUS_IFACE,
631                 MODEST_DBUS_METHOD_SEARCH);
632
633     if (msg == NULL) {
634         //ULOG_ERR_F("dbus_message_new_method_call failed");
635                 return OSSO_ERROR;
636     }
637
638         if (folder == NULL) {
639                 folder = "";
640         }
641
642         sd_v = (dbus_int64_t) start_date;
643         ed_v = (dbus_int64_t) end_date;
644         flags_v = (dbus_int32_t) flags;
645         size_v = (dbus_uint32_t) min_size;
646
647         res  = dbus_message_append_args (msg,
648                                          DBUS_TYPE_STRING, &query,
649                                          DBUS_TYPE_STRING, &folder,
650                                          DBUS_TYPE_INT64, &sd_v,
651                                          DBUS_TYPE_INT64, &ed_v,
652                                          DBUS_TYPE_INT32, &flags_v,
653                                          DBUS_TYPE_UINT32, &size_v,
654                                          DBUS_TYPE_INVALID);
655
656         dbus_message_set_auto_start (msg, TRUE);
657
658         /* Use a long timeout (2 minutes) because the search currently 
659          * gets folders and messages from the servers. */
660         timeout = 120000; //milliseconds.
661         //osso_rpc_get_timeout (osso_ctx, &timeout);
662
663     /*printf("DEBUG: %s: Before dbus_connection_send_with_reply_and_block().\n", 
664                 __FUNCTION__); */
665         /* TODO: Detect the timeout somehow. */
666         DBusError err;
667         dbus_error_init (&err);
668         reply = dbus_connection_send_with_reply_and_block (con,
669                                                            msg, 
670                                                            timeout,
671                                                            &err);
672         /* printf("DEBUG: %s: dbus_connection_send_with_reply_and_block() finished.\n", 
673                 __FUNCTION__); */
674
675         dbus_message_unref (msg);
676
677         if (!reply) {
678                 g_warning("%s: dbus_connection_send_with_reply_and_block() error: %s", 
679                         __FUNCTION__, err.message);
680                 return FALSE;
681         }
682
683         switch (dbus_message_get_type (reply)) {
684
685                 case DBUS_MESSAGE_TYPE_ERROR:
686                         dbus_set_error_from_message (&err, reply);
687                         //XXX to GError?!
688                         dbus_error_free (&err);
689                         dbus_message_unref (reply);
690                         return FALSE;
691
692                 case DBUS_MESSAGE_TYPE_METHOD_RETURN:
693                         /* ok we are good to go
694                          * lets drop outa here and handle that */
695                         break;
696                 default:
697                         //ULOG_WARN_F("got unknown message type as reply");
698                         //retval->type = DBUS_TYPE_STRING;
699                         //retval->value.s = g_strdup("Invalid return value");
700                         //XXX to GError?! 
701                         dbus_message_unref (reply);
702                         return FALSE;
703         }
704
705         g_debug ("%s: message return", __FUNCTION__);
706
707         dbus_message_iter_init (reply, &iter);
708         arg_type = dbus_message_iter_get_arg_type (&iter);
709         
710         dbus_message_iter_recurse (&iter, &child);
711         *hits = NULL;
712
713         do {
714                 ModestSearchHit *hit;
715
716                 hit = modest_dbus_message_iter_get_search_hit (&child);
717
718                 if (hit) {
719                         *hits = g_list_prepend (*hits, hit);    
720                 }
721
722         } while (dbus_message_iter_next (&child));
723
724         dbus_message_unref (reply);
725
726
727         /* TODO: This is from osso source, do we need it? */
728 #if 0
729         /* Tell TaskNavigator to show "launch banner" */
730         msg = dbus_message_new_method_call (TASK_NAV_SERVICE,
731                                             APP_LAUNCH_BANNER_METHOD_PATH,
732                                             APP_LAUNCH_BANNER_METHOD_INTERFACE,
733                                             APP_LAUNCH_BANNER_METHOD);
734
735         if (msg == NULL) {
736                 g_warn ("dbus_message_new_method_call failed");
737         }
738
739
740
741         dbus_message_append_args (msg,
742                                   DBUS_TYPE_STRING,
743                                   &service,
744                                   DBUS_TYPE_INVALID);
745
746         b = dbus_connection_send (conn, msg, NULL);
747
748         if (b == NULL) {
749                 ULOG_WARN_F("dbus_connection_send failed");
750         }
751
752         dbus_message_unref (msg);
753 #endif
754
755         return TRUE;
756 }
757
758
759 static void
760 modest_folder_result_free (ModestFolderResult *item)
761 {
762         g_free (item->folder_name);
763         g_free (item->folder_uri);
764         g_slice_free (ModestFolderResult, item);
765 }
766
767 void
768 modest_folder_result_list_free (GList *list)
769 {
770         GList *iter;
771
772         if (list == NULL) {
773                 return;
774         }
775
776         for (iter = list; iter; iter = iter->next) {
777                 modest_folder_result_free ((ModestFolderResult *) iter->data);
778         }
779
780         g_list_free (list);
781 }
782
783
784 /** Get the values from the complex type (GET_FOLDERS_RESULT_DBUS_TYPE)
785  * in the D-Bus return message. */
786 static ModestFolderResult *
787 modest_dbus_message_iter_get_folder_item (DBusMessageIter *parent)
788 {
789         gboolean error = FALSE;
790         ModestFolderResult *item = g_slice_new0 (ModestFolderResult);
791
792         int arg_type = dbus_message_iter_get_arg_type (parent);
793
794         if (arg_type != 'r') {
795                 return NULL;
796         }
797
798         DBusMessageIter  child;
799         dbus_message_iter_recurse (parent, &child);
800         
801         /* folder name: */
802         arg_type = dbus_message_iter_get_arg_type (&child);
803
804         if (arg_type != DBUS_TYPE_STRING) {
805                 error = TRUE;
806                 goto out;
807         }
808
809         item->folder_name = _dbus_iter_get_string_or_null (&child);
810         
811         
812         dbus_bool_t res = dbus_message_iter_next (&child);
813         if (res == FALSE) {
814                 error = TRUE;
815                 goto out;
816         }
817
818         /* folder URI:  */
819         arg_type = dbus_message_iter_get_arg_type (&child);
820
821         if (arg_type != DBUS_TYPE_STRING) {
822                 error = TRUE;
823                 goto out;
824         }
825
826         item->folder_uri = _dbus_iter_get_string_or_null (&child);
827
828
829 out:
830         if (error) {
831                 g_warning ("%s: Error during unmarshalling", __FUNCTION__);
832                 modest_folder_result_free (item);
833                 item = NULL;
834         }
835
836         return item;
837 }
838
839 /**
840  * libmodest_dbus_client_get_folders:
841  * @osso_ctx: A valid #osso_context_t object.
842  * @folders: A pointer to a valid GList pointer that will contain the folder items
843  * (ModestFolderResult). The list and the items must be freed by the caller 
844  * with modest_folder_result_list_free().
845  *
846  * This method will obtain a list of folders in the default account.
847  *
848  * Upon success TRUE is returned and @folders will include the folders or the list
849  * might be empty if there are no folders. The returned
850  * list must be freed with modest_folder_result_list_free ().
851  *
852  * NOTE: A folder will only be retrieved if it was previously downloaded by
853  * modest. This function does also not attempt do to remote refreshes (i.e. IMAP).
854  * 
855  * Return value: TRUE if the request succeded or FALSE for an error.
856  **/
857 gboolean
858 libmodest_dbus_client_get_folders (osso_context_t          *osso_ctx,
859                               GList                  **folders)
860 {
861         /* Initialize output argument: */
862         if (folders)
863                 *folders = NULL;
864         else
865                 return FALSE;
866
867         DBusConnection *con = osso_get_dbus_connection (osso_ctx);
868
869         if (con == NULL) {
870                 g_warning ("Could not get dbus connection\n");
871                 return FALSE;
872
873         }
874
875         DBusMessage *msg = dbus_message_new_method_call (MODEST_DBUS_SERVICE,
876                 MODEST_DBUS_OBJECT,
877                 MODEST_DBUS_IFACE,
878                 MODEST_DBUS_METHOD_GET_FOLDERS);
879
880     if (msg == NULL) {
881         //ULOG_ERR_F("dbus_message_new_method_call failed");
882                 return OSSO_ERROR;
883     }
884
885         dbus_message_set_auto_start (msg, TRUE);
886
887         /* Use a long timeout (2 minutes) because the search currently 
888          * gets folders from the servers. */
889         gint timeout = 120000;
890         //osso_rpc_get_timeout (osso_ctx, &timeout);
891
892         DBusError err;
893         dbus_error_init (&err);
894         DBusMessage *reply = dbus_connection_send_with_reply_and_block (con,
895                                                            msg, 
896                                                            timeout,
897                                                            &err);
898
899         dbus_message_unref (msg);
900         msg = NULL;
901
902         if (reply == NULL) {
903                 g_warning("%s: dbus_connection_send_with_reply_and_block() error:\n   %s", 
904                         __FUNCTION__, err.message);
905                 return FALSE;
906         }
907
908         switch (dbus_message_get_type (reply)) {
909
910                 case DBUS_MESSAGE_TYPE_ERROR:
911                         dbus_set_error_from_message (&err, reply);
912                         //XXX to GError?!
913                         dbus_error_free (&err);
914                         dbus_message_unref (reply);
915                         return FALSE;
916
917                 case DBUS_MESSAGE_TYPE_METHOD_RETURN:
918                         /* ok we are good to go
919                          * lets drop outa here and handle that */
920                         break;
921                 default:
922                         //ULOG_WARN_F("got unknown message type as reply");
923                         //retval->type = DBUS_TYPE_STRING;
924                         //retval->value.s = g_strdup("Invalid return value");
925                         //XXX to GError?! 
926                         dbus_message_unref (reply);
927                         return FALSE;
928         }
929
930         g_debug ("%s: message return", __FUNCTION__);
931
932         DBusMessageIter iter;
933         dbus_message_iter_init (reply, &iter);
934         /* int arg_type = dbus_message_iter_get_arg_type (&iter); */
935         
936         DBusMessageIter child;
937         dbus_message_iter_recurse (&iter, &child);
938
939         do {
940                 ModestFolderResult *item = modest_dbus_message_iter_get_folder_item (&child);
941
942                 if (item) {
943                         *folders = g_list_append (*folders, item);      
944                 }
945
946         } while (dbus_message_iter_next (&child));
947
948         dbus_message_unref (reply);
949
950
951         /* TODO: This is from osso source, do we need it? */
952 #if 0
953         /* Tell TaskNavigator to show "launch banner" */
954         msg = dbus_message_new_method_call (TASK_NAV_SERVICE,
955                                             APP_LAUNCH_BANNER_METHOD_PATH,
956                                             APP_LAUNCH_BANNER_METHOD_INTERFACE,
957                                             APP_LAUNCH_BANNER_METHOD);
958
959         if (msg == NULL) {
960                 g_warn ("dbus_message_new_method_call failed");
961         }
962
963
964
965         dbus_message_append_args (msg,
966                                   DBUS_TYPE_STRING,
967                                   &service,
968                                   DBUS_TYPE_INVALID);
969
970         b = dbus_connection_send (conn, msg, NULL);
971
972         if (b == NULL) {
973                 ULOG_WARN_F("dbus_connection_send failed");
974         }
975
976         dbus_message_unref (msg);
977 #endif
978
979         return TRUE;
980 }
981
982