1 /* Copyright (c) 2007, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
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.
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.
30 #include "libmodest-dbus-client.h"
31 #include <dbus_api/modest-dbus-api.h> /* For the API strings. */
33 //#define DBUS_API_SUBJECT_TO_CHANGE 1
34 #include <dbus/dbus.h>
35 #include <dbus/dbus-glib-lowlevel.h>
40 /** Get a comma-separated list of attachement URI strings,
41 * from a list of strings.
43 static gchar* get_attachments_string (GSList *attachments)
48 gchar *attachments_str = g_strdup("");
50 GSList *iter = attachments;
54 gchar *tmp = g_strconcat(attachments_str, ",", (gchar *) (iter->data), NULL);
55 g_free(attachments_str);
56 attachments_str = tmp;
59 iter = g_slist_next(iter);
62 return attachments_str;
66 * libmodest_dbus_client_mail_to:
67 * @osso_context: a valid #osso_context_t object.
68 * @mailto_uri: A mailto URI.
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.
74 * Return value: Whether or not the rpc call to modest
78 libmodest_dbus_client_mail_to (osso_context_t *osso_context, const gchar *mailto_uri)
81 const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
83 MODEST_DBUS_METHOD_MAIL_TO, &retval,
84 DBUS_TYPE_STRING, mailto_uri,
88 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
91 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
94 osso_rpc_free_val(&retval);
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.
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.
113 * Return value: Whether or not the rpc call to modest
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)
122 gchar *attachments_str = get_attachments_string(attachments);
124 const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
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,
135 g_free (attachments_str);
137 if (ret != OSSO_OK) {
138 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
141 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
144 osso_rpc_free_val(&retval);
151 * libmodest_dbus_client_open_message:
152 * @osso_context: a valid #osso_context_t object.
153 * @msg_uri: A valid url to a mail
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
160 * Return value: TRUE on successs, FALSE on error
163 libmodest_dbus_client_open_message (osso_context_t *osso_context, const gchar *mail_uri)
166 const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
168 MODEST_DBUS_METHOD_OPEN_MESSAGE, &retval,
169 DBUS_TYPE_STRING, mail_uri,
172 if (ret != OSSO_OK) {
173 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
176 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
179 osso_rpc_free_val(&retval);
185 libmodest_dbus_client_send_and_receive (osso_context_t *osso_context)
188 const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
190 MODEST_DBUS_METHOD_SEND_RECEIVE, &retval,
193 if (ret != OSSO_OK) {
194 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
197 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
200 osso_rpc_free_val(&retval);
206 libmodest_dbus_client_open_default_inbox (osso_context_t *osso_context)
209 const osso_return_t ret = osso_rpc_run_with_defaults(osso_context,
211 MODEST_DBUS_METHOD_OPEN_DEFAULT_INBOX, &retval,
214 if (ret != OSSO_OK) {
215 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
218 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
221 osso_rpc_free_val(&retval);
227 libmodest_dbus_client_open_account (osso_context_t *osso_context,
228 const gchar *account_id)
231 const osso_return_t ret =
232 osso_rpc_run_with_defaults(osso_context,
234 MODEST_DBUS_METHOD_OPEN_ACCOUNT, &retval,
235 DBUS_TYPE_STRING, account_id,
238 if (ret != OSSO_OK) {
239 printf("debug: %s: osso_rpc_run() failed.\n", __FUNCTION__);
242 printf("debug: %s: osso_rpc_run() succeeded.\n", __FUNCTION__);
245 osso_rpc_free_val(&retval);
251 * libmodest_dbus_client_delete_message:
252 * @osso_context: a valid #osso_context_t object.
253 * @msg_uri: A valid url to a mail
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.
259 * Return value: TRUE on successs, FALSE on error
262 libmodest_dbus_client_delete_message (osso_context_t *osso_ctx,
268 ret = osso_rpc_run_with_defaults (osso_ctx,
270 MODEST_DBUS_METHOD_DELETE_MESSAGE, &retval,
271 DBUS_TYPE_STRING, msg_uri,
274 if (ret != OSSO_OK) {
275 g_debug ("debug: osso_rpc_run() failed.\n");
277 g_debug ("debug: osso_rpc_run() succeeded.\n");
280 osso_rpc_free_val (&retval);
282 return ret == OSSO_OK;
286 modest_search_hit_free (ModestSearchHit *hit)
289 g_slice_free (ModestSearchHit, hit);
293 modest_search_hit_list_free (GList *hits)
301 for (iter = hits; iter; iter = iter->next) {
302 modest_search_hit_free ((ModestSearchHit *) iter->data);
309 _dbus_iter_get_string_or_null (DBusMessageIter *iter)
311 const char *string = NULL;
314 dbus_message_iter_get_basic (iter, &string);
316 if (string && strlen (string)) {
317 ret = g_strdup (string);
324 _dbus_iter_get_uint64 (DBusMessageIter *iter)
330 dbus_message_iter_get_basic (iter, &ui64v);
332 ret = (guint64) ui64v;
339 _dbus_iter_get_int64 (DBusMessageIter *iter)
345 dbus_message_iter_get_basic (iter, &i64v);
353 _dbus_iter_get_boolean (DBusMessageIter *iter)
360 dbus_message_iter_get_basic (iter, &val);
362 ret = (gboolean) val;
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)
372 ModestSearchHit *hit;
373 DBusMessageIter child;
379 hit = g_slice_new0 (ModestSearchHit);
381 arg_type = dbus_message_iter_get_arg_type (parent);
383 if (arg_type != 'r') {
387 dbus_message_iter_recurse (parent, &child);
390 arg_type = dbus_message_iter_get_arg_type (&child);
392 if (arg_type != DBUS_TYPE_STRING) {
397 hit->msgid = _dbus_iter_get_string_or_null (&child);
399 res = dbus_message_iter_next (&child);
406 arg_type = dbus_message_iter_get_arg_type (&child);
408 if (arg_type != DBUS_TYPE_STRING) {
413 hit->subject = _dbus_iter_get_string_or_null (&child);
415 res = dbus_message_iter_next (&child);
422 arg_type = dbus_message_iter_get_arg_type (&child);
424 if (arg_type != DBUS_TYPE_STRING) {
429 hit->folder = _dbus_iter_get_string_or_null (&child);
431 res = dbus_message_iter_next (&child);
438 arg_type = dbus_message_iter_get_arg_type (&child);
440 if (arg_type != DBUS_TYPE_STRING) {
445 hit->sender = _dbus_iter_get_string_or_null (&child);
447 res = dbus_message_iter_next (&child);
454 arg_type = dbus_message_iter_get_arg_type (&child);
456 if (arg_type != DBUS_TYPE_UINT64) {
461 hit->msize = _dbus_iter_get_uint64 (&child);
463 res = dbus_message_iter_next (&child);
470 arg_type = dbus_message_iter_get_arg_type (&child);
472 if (arg_type != DBUS_TYPE_BOOLEAN) {
477 hit->has_attachment = _dbus_iter_get_boolean (&child);
479 res = dbus_message_iter_next (&child);
486 arg_type = dbus_message_iter_get_arg_type (&child);
488 if (arg_type != DBUS_TYPE_BOOLEAN) {
493 hit->is_unread = _dbus_iter_get_boolean (&child);
495 res = dbus_message_iter_next (&child);
502 arg_type = dbus_message_iter_get_arg_type (&child);
504 if (arg_type != DBUS_TYPE_INT64) {
509 hit->timestamp = _dbus_iter_get_int64 (&child);
511 res = dbus_message_iter_next (&child);
519 g_warning ("%s: Error during unmarshalling", __FUNCTION__);
520 modest_search_hit_free (hit);
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().
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.
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.
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).
560 * Example to search every account for message containing "no":
561 * <informalexample><programlisting>
562 * ModestDBusSearchFlags flags;
563 * osso_context_t *osso_context;
568 * [...] Initialize osso context [...]
570 * res = libmodest_dbus_client_search (osso_context,
579 * for (iter = hits; iter; iter = iter->next) {
580 * ModestSearchHit *hit = (ModestSearchHit *) iter->data;
582 * [...] Do something with the hit [...]
586 * modest_search_hit_list_free (hits);
587 * </programlisting></informalexample>
589 * Return value: TRUE if the search succeded or FALSE for an error during the search
592 libmodest_dbus_client_search (osso_context_t *osso_ctx,
598 ModestDBusSearchFlags flags,
605 DBusMessageIter iter;
606 DBusMessageIter child;
607 DBusMessage *reply = NULL;
612 dbus_int32_t flags_v;
613 dbus_uint32_t size_v;
619 con = osso_get_dbus_connection (osso_ctx);
622 g_warning ("Could not get dbus connection\n");
628 msg = dbus_message_new_method_call (MODEST_DBUS_SERVICE,
631 MODEST_DBUS_METHOD_SEARCH);
634 //ULOG_ERR_F("dbus_message_new_method_call failed");
638 if (folder == NULL) {
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;
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,
656 dbus_message_set_auto_start (msg, TRUE);
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);
663 /*printf("DEBUG: %s: Before dbus_connection_send_with_reply_and_block().\n",
665 /* TODO: Detect the timeout somehow. */
667 dbus_error_init (&err);
668 reply = dbus_connection_send_with_reply_and_block (con,
672 /* printf("DEBUG: %s: dbus_connection_send_with_reply_and_block() finished.\n",
675 dbus_message_unref (msg);
678 g_warning("%s: dbus_connection_send_with_reply_and_block() error: %s",
679 __FUNCTION__, err.message);
683 switch (dbus_message_get_type (reply)) {
685 case DBUS_MESSAGE_TYPE_ERROR:
686 dbus_set_error_from_message (&err, reply);
688 dbus_error_free (&err);
689 dbus_message_unref (reply);
692 case DBUS_MESSAGE_TYPE_METHOD_RETURN:
693 /* ok we are good to go
694 * lets drop outa here and handle that */
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");
701 dbus_message_unref (reply);
705 g_debug ("%s: message return", __FUNCTION__);
707 dbus_message_iter_init (reply, &iter);
708 arg_type = dbus_message_iter_get_arg_type (&iter);
710 dbus_message_iter_recurse (&iter, &child);
714 ModestSearchHit *hit;
716 hit = modest_dbus_message_iter_get_search_hit (&child);
719 *hits = g_list_prepend (*hits, hit);
722 } while (dbus_message_iter_next (&child));
724 dbus_message_unref (reply);
727 /* TODO: This is from osso source, do we need it? */
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);
736 g_warn ("dbus_message_new_method_call failed");
741 dbus_message_append_args (msg,
746 b = dbus_connection_send (conn, msg, NULL);
749 ULOG_WARN_F("dbus_connection_send failed");
752 dbus_message_unref (msg);
760 modest_folder_result_free (ModestFolderResult *item)
762 g_free (item->folder_name);
763 g_free (item->folder_uri);
764 g_slice_free (ModestFolderResult, item);
768 modest_folder_result_list_free (GList *list)
776 for (iter = list; iter; iter = iter->next) {
777 modest_folder_result_free ((ModestFolderResult *) iter->data);
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)
789 gboolean error = FALSE;
790 ModestFolderResult *item = g_slice_new0 (ModestFolderResult);
792 int arg_type = dbus_message_iter_get_arg_type (parent);
794 if (arg_type != 'r') {
798 DBusMessageIter child;
799 dbus_message_iter_recurse (parent, &child);
802 arg_type = dbus_message_iter_get_arg_type (&child);
804 if (arg_type != DBUS_TYPE_STRING) {
809 item->folder_name = _dbus_iter_get_string_or_null (&child);
812 dbus_bool_t res = dbus_message_iter_next (&child);
819 arg_type = dbus_message_iter_get_arg_type (&child);
821 if (arg_type != DBUS_TYPE_STRING) {
826 item->folder_uri = _dbus_iter_get_string_or_null (&child);
831 g_warning ("%s: Error during unmarshalling", __FUNCTION__);
832 modest_folder_result_free (item);
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().
846 * This method will obtain a list of folders in the default account.
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 ().
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).
855 * Return value: TRUE if the request succeded or FALSE for an error.
858 libmodest_dbus_client_get_folders (osso_context_t *osso_ctx,
861 /* Initialize output argument: */
867 DBusConnection *con = osso_get_dbus_connection (osso_ctx);
870 g_warning ("Could not get dbus connection\n");
875 DBusMessage *msg = dbus_message_new_method_call (MODEST_DBUS_SERVICE,
878 MODEST_DBUS_METHOD_GET_FOLDERS);
881 //ULOG_ERR_F("dbus_message_new_method_call failed");
885 dbus_message_set_auto_start (msg, TRUE);
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);
893 dbus_error_init (&err);
894 DBusMessage *reply = dbus_connection_send_with_reply_and_block (con,
899 dbus_message_unref (msg);
903 g_warning("%s: dbus_connection_send_with_reply_and_block() error:\n %s",
904 __FUNCTION__, err.message);
908 switch (dbus_message_get_type (reply)) {
910 case DBUS_MESSAGE_TYPE_ERROR:
911 dbus_set_error_from_message (&err, reply);
913 dbus_error_free (&err);
914 dbus_message_unref (reply);
917 case DBUS_MESSAGE_TYPE_METHOD_RETURN:
918 /* ok we are good to go
919 * lets drop outa here and handle that */
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");
926 dbus_message_unref (reply);
930 g_debug ("%s: message return", __FUNCTION__);
932 DBusMessageIter iter;
933 dbus_message_iter_init (reply, &iter);
934 /* int arg_type = dbus_message_iter_get_arg_type (&iter); */
936 DBusMessageIter child;
937 dbus_message_iter_recurse (&iter, &child);
940 ModestFolderResult *item = modest_dbus_message_iter_get_folder_item (&child);
943 *folders = g_list_append (*folders, item);
946 } while (dbus_message_iter_next (&child));
948 dbus_message_unref (reply);
951 /* TODO: This is from osso source, do we need it? */
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);
960 g_warn ("dbus_message_new_method_call failed");
965 dbus_message_append_args (msg,
970 b = dbus_connection_send (conn, msg, NULL);
973 ULOG_WARN_F("dbus_connection_send failed");
976 dbus_message_unref (msg);