X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fdbus_api%2Fmodest-dbus-callbacks.c;h=875eb092c627d3ee8f6cbd7724f4085740a89ca6;hp=ab7e1d8346d7ead417c1f32ab4ac75c8ec24b154;hb=be6ccffc543395f60cd1e8551d0df6f8f037a8d5;hpb=ba2367f68072eaed88c44e2def818520dbc934e1

diff --git a/src/dbus_api/modest-dbus-callbacks.c b/src/dbus_api/modest-dbus-callbacks.c
index ab7e1d8..875eb09 100644
--- a/src/dbus_api/modest-dbus-callbacks.c
+++ b/src/dbus_api/modest-dbus-callbacks.c
@@ -32,11 +32,22 @@
 #include "modest-account-mgr.h"
 #include "modest-account-mgr-helpers.h"
 #include "modest-tny-account.h"
+#include "modest-ui-actions.h"
+
+#include "modest-search.h"
 #include "widgets/modest-msg-edit-window.h"
 #include "modest-tny-msg.h"
+#include <libmodest-dbus-client/libmodest-dbus-client.h>
 #include <libgnomevfs/gnome-vfs-utils.h>
 #include <stdio.h>
 #include <string.h>
+#include <glib/gstdio.h>
+#include <libgnomevfs/gnome-vfs-mime.h>
+#include <tny-fs-stream.h>
+
+#include <tny-list.h>
+#include <tny-iterator.h>
+#include <tny-simple-list.h>
 
 typedef struct 
 {
@@ -47,6 +58,16 @@ typedef struct
  	gchar *body;
 } SendMailIdleData;
 
+typedef struct 
+{
+	gchar *to;
+ 	gchar *cc;
+ 	gchar *bcc;
+ 	gchar *subject;
+ 	gchar *body;
+	gchar *attachments;
+} ComposeMailIdleData;
+
 static gboolean
 on_idle_send_mail(gpointer user_data)
 {
@@ -78,11 +99,12 @@ on_idle_send_mail(gpointer user_data)
 		if (!from) {
 			g_printerr ("modest: no from address for account '%s'\n", account_name);
 		} else {
-			ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_SEND);
+			ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, NULL);
 			modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
 			
 	 		modest_mail_operation_send_new_mail (mail_operation,
 					     transport_account,
+					     NULL,
 					     from, /* from */
 					     idle_data->to, idle_data->cc, idle_data->bcc, idle_data->subject, 
 					     idle_data->body, /* plain_body */
@@ -375,14 +397,226 @@ static gint on_mail_to(GArray * arguments, gpointer data, osso_rpc_t * retval)
 }
 
 
+
+
+
 static gboolean
-on_idle_open_message(gpointer user_data)
+on_idle_compose_mail(gpointer user_data)
 {
-	gchar *uri = (gchar*)user_data;
+	ComposeMailIdleData *idle_data = (ComposeMailIdleData*)user_data;
+	gchar **list = NULL;
+	gint i = 0;
+
+	/* Get the TnyTransportAccount so we can instantiate a mail operation: */
+ 	ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
+	gchar *account_name = modest_account_mgr_get_default_account (account_mgr);
+	if (!account_name) {
+		g_printerr ("modest: no account found\n");
+	}
 	
-	g_message ("not implemented yet %s", __FUNCTION__);
+	TnyAccount *account = NULL;
+	if (account_mgr) {
+		account = modest_tny_account_store_get_transport_account_for_open_connection (
+			modest_runtime_get_account_store(), account_name);
+	}
+	
+	if (!account) {
+		g_printerr ("modest: failed to get tny account folder'%s'\n", account_name);
+	} else {
+		gchar * from = modest_account_mgr_get_from_string (account_mgr,
+								  account_name);
+		if (!from) {
+			g_printerr ("modest: no from address for account '%s'\n", account_name);
+		} else {
+	
+			/* Create the message: */
+			TnyMsg *msg  = modest_tny_msg_new (idle_data->to, from, 
+				idle_data->cc, idle_data->bcc, idle_data->subject, idle_data->body, 
+				NULL); /* NULL because m_t_m_n doesn't use it */
+				
+			if (!msg) {
+				g_printerr ("modest: failed to create message\n");
+			} else
+			{
+				/* Add the message to a folder and show its UI for editing: */
+				TnyFolder *folder = modest_tny_account_get_special_folder (account,
+									TNY_FOLDER_TYPE_DRAFTS);
+				if (!folder) {
+					g_printerr ("modest: failed to find Drafts folder\n");
+				} else {
+			
+					tny_folder_add_msg (folder, msg, NULL); /* TODO: check err */
+		
+					ModestWindow *win = modest_msg_edit_window_new (msg, account_name);
+
+					list = g_strsplit(idle_data->attachments, ",", 0);
+					for (i=0; list[i] != NULL; i++) {
+						modest_msg_edit_window_attach_file_noninteractive(
+								(ModestMsgEditWindow *)win, list[i]);
+					}
+					g_strfreev(list);
+					
+					gtk_widget_show_all (GTK_WIDGET (win));
+				
+					g_object_unref (G_OBJECT(folder));
+				}
+			
+				g_object_unref (G_OBJECT(msg));
+			}
+			
+			g_object_unref (G_OBJECT(account));
+		}
+ 	}
+
+ 	/* Free the idle data: */
+	g_free (idle_data->to);
+	g_free (idle_data->cc);
+	g_free (idle_data->bcc);
+	g_free (idle_data->subject);
+	g_free (idle_data->body);
+	g_free (idle_data->attachments);
+	g_free (idle_data);
+	
+ 	g_free (account_name);
+	return FALSE; /* Do not call this callback again. */
+}
+
+static gint on_compose_mail(GArray * arguments, gpointer data, osso_rpc_t * retval)
+{
+
+	
+	if (arguments->len != MODEST_DEBUS_COMPOSE_MAIL_ARGS_COUNT)
+     	return OSSO_ERROR;
+     	
+	/* Use g_idle to context-switch into the application's thread: */
+ 	ComposeMailIdleData *idle_data = g_new0(ComposeMailIdleData, 1); /* Freed in the idle callback. */
+ 	
+	/* Get the arguments: */
+ 	osso_rpc_t val = g_array_index(arguments, osso_rpc_t, MODEST_DEBUS_COMPOSE_MAIL_ARG_TO);
+ 	idle_data->to = g_strdup (val.value.s);
+ 	
+ 	val = g_array_index(arguments, osso_rpc_t, MODEST_DEBUS_COMPOSE_MAIL_ARG_CC);
+ 	idle_data->cc = g_strdup (val.value.s);
+ 	
+ 	val = g_array_index(arguments, osso_rpc_t, MODEST_DEBUS_COMPOSE_MAIL_ARG_BCC);
+ 	idle_data->bcc = g_strdup (val.value.s);
+ 	
+ 	val = g_array_index(arguments, osso_rpc_t, MODEST_DEBUS_COMPOSE_MAIL_ARG_SUBJECT);
+ 	idle_data->subject = g_strdup (val.value.s);
+ 	
+ 	val = g_array_index(arguments, osso_rpc_t, MODEST_DEBUS_COMPOSE_MAIL_ARG_BODY);
+ 	idle_data->body = g_strdup (val.value.s);
+ 	
+ 	val = g_array_index(arguments, osso_rpc_t, MODEST_DEBUS_COMPOSE_MAIL_ARG_ATTACHMENTS);
+ 	idle_data->attachments = g_strdup (val.value.s);
+
+  	g_idle_add(on_idle_compose_mail, (gpointer)idle_data);
+ 	
+ 	/* Note that we cannot report failures during sending, 
+ 	 * because that would be asynchronous. */
+ 	return OSSO_OK;
+}
+
+
+static TnyMsg *
+find_message_by_url (const char *uri, TnyAccount **ac_out)
+{
+
+	ModestTnyAccountStore *astore;
+	TnyAccount            *account;
+	TnyFolder             *folder;
+	TnyMsg                *msg;
+
+	account = NULL;
+	msg = NULL;
+	folder = NULL;
+
+	astore = modest_runtime_get_account_store ();
+	
+	if (astore == NULL) {
+		return NULL;
+	}
+	
+	g_debug ("Got AccountStore, lets go");
+
+	account = tny_account_store_find_account (TNY_ACCOUNT_STORE (astore),
+						  uri);
+	
+	if (account == NULL) {
+		return NULL;
+	}
+
+	g_debug ("Found account");
+
+	if ( ! TNY_IS_STORE_ACCOUNT (account)) {
+		goto out;
+	}
+
+	g_debug ("Account is store account");
+
+	*ac_out = account;
+
+	folder = tny_store_account_find_folder (TNY_STORE_ACCOUNT (account),
+						uri,
+						NULL);
+
+	if (folder == NULL) {
+		goto out;
+	}
+	g_debug ("Found folder");
+	
+
+	msg = tny_folder_find_msg (folder, uri, NULL);
+
+out:
+	if (account && !msg) {
+		g_object_unref (account);
+		*ac_out = NULL;
+	}
+
+	if (folder) {
+		g_object_unref (folder);
+	}
+
+	return msg;
+}
+
+static gboolean
+on_idle_open_message (gpointer user_data)
+{
+	ModestWindow *msg_view;
+	TnyMsg       *msg;
+	TnyAccount   *account;
+	TnyHeader    *header; 
+	const char   *msg_uid;
+	const char   *account_name;
+	char         *uri;
+       
+	uri = (char *) user_data;
+
+	g_debug ("Trying to find msg by url: %s", uri);	
+	msg = find_message_by_url (uri, &account);
+	g_free (uri);
+
+	if (msg == NULL) {
+		return FALSE;
+	}
+	g_debug ("Found message");
+
+	header = tny_msg_get_header (msg);
+	account_name = tny_account_get_name (account);
+	msg_uid = tny_header_get_uid (header);
+	
+	msg_view = modest_msg_view_window_new (msg,
+					       account_name,
+					       msg_uid);
+	/* TODO: does that leak the msg_view ?! */
+
+	gtk_widget_show_all (GTK_WIDGET (msg_view));
+
+	g_object_unref (header);
+	g_object_unref (account);
 	
-	g_free(uri);
 	return FALSE; /* Do not call this callback again. */
 }
 
@@ -404,31 +638,395 @@ static gint on_open_message(GArray * arguments, gpointer data, osso_rpc_t * retv
  	 * because that would be asynchronous. */
  	return OSSO_OK;
 }
+
+
+static gint
+on_delete_message (GArray *arguments, gpointer data, osso_rpc_t *retval)
+{
+	TnyList      *headers;
+	TnyFolder    *folder;
+	TnyIterator  *iter; 
+	TnyHeader    *header;
+	TnyHeader    *msg_header;
+	TnyMsg       *msg;
+	TnyAccount   *account;
+	GError       *error;
+	osso_rpc_t    val;
+	const char   *uri;
+	const char   *uid;
+	gint          res;
+
+	if (arguments->len != MODEST_DEBUS_DELETE_MESSAGE_ARGS_COUNT) {
+		return OSSO_ERROR;
+	}
+
+	val = g_array_index (arguments,
+			     osso_rpc_t,
+			     MODEST_DEBUS_DELETE_MESSAGE_ARG_URI);
+
+	uri = (const char *) val.value.s;
+
+	g_debug ("Searching message (delete message)");
+	
+	msg = find_message_by_url (uri, &account);
+
+	if (msg == NULL) {
+		return OSSO_ERROR;
+	}
+
+	g_debug ("Found message");
+	
+	msg_header = tny_msg_get_header (msg);
+	uid = tny_header_get_uid (msg_header);
+	folder = tny_msg_get_folder (msg);
+
+
+	/* tny_msg_get_header () flaw:
+	 * From tinythingy doc: You can't use the returned instance with the
+	 * TnyFolder operations
+	 *
+	 * To get a header instance that will work with these folder methods,
+	 * you can use tny_folder_get_headers.
+	 *
+	 * Ok, we will do so then. Sigh.
+	 * */
+	headers = tny_simple_list_new ();
+
+	tny_folder_get_headers (folder, headers, TRUE, NULL);
+	iter = tny_list_create_iterator (headers);
+	header = NULL;
+
+	g_debug ("Searching header for msg in folder");
+	while (!tny_iterator_is_done (iter)) {
+		const char *cur_id;
+
+		header = TNY_HEADER (tny_iterator_get_current (iter));
+		cur_id = tny_header_get_uid (header);
+		
+		if (cur_id && uid && g_str_equal (cur_id, uid)) {
+			g_debug ("Found correspoding header from folder");
+			break;
+		}
+
+		header = NULL;
+		g_object_unref (header);
+		tny_iterator_next (iter);
+	}
+
+	g_object_unref (iter);
+	g_object_unref (headers);
+	
+	g_object_unref (msg_header);
+	g_object_unref (msg);
+
+	if (header == NULL) {
+		g_object_unref (folder);
+		return OSSO_ERROR;
+	}
+
+
+	error = NULL;
+	res = OSSO_OK;
+	tny_folder_remove_msg (folder, header, &error);
+
+	if (error != NULL) {
+		res = OSSO_ERROR;
+		g_error_free (error);
+	}
+
+	g_object_unref (folder);
+	return res;
+}
+
+static gboolean
+on_idle_send_receive(gpointer user_data)
+{
+	ModestWindow *win;
+
+	/* Pick the main window if it exists */
+	win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
+
+	/* Send & receive all if "Update automatically" is set */
+	/* TODO: check the auto-update parameter in the configuration */
+	modest_ui_actions_do_send_receive_all (win);
+	
+	return FALSE; /* Do not call this callback again. */
+}
+
+static gint on_send_receive(GArray * arguments, gpointer data, osso_rpc_t * retval)
+{ 	
+    /* Use g_idle to context-switch into the application's thread: */
+
+    /* This method has no arguments. */
+ 	
+ 	/* printf("  debug: to=%s\n", idle_data->to); */
+ 	g_idle_add(on_idle_send_receive, NULL);
+ 	
+ 	/* Note that we cannot report failures during send/receive, 
+ 	 * because that would be asynchronous. */
+ 	return OSSO_OK;
+}
                       
 /* Callback for normal D-BUS messages */
 gint modest_dbus_req_handler(const gchar * interface, const gchar * method,
                       GArray * arguments, gpointer data,
                       osso_rpc_t * retval)
 {
-	/*
-	printf("debug: modest_dbus_req_handler()\n");
-	printf("debug: method received: %s\n", method);
-	*/
+	
+	g_debug ("modest_dbus_req_handler()\n");
+	g_debug ("debug: method received: %s\n", method);
+	
 	if (g_ascii_strcasecmp(method, MODEST_DBUS_METHOD_SEND_MAIL) == 0) {
 		return on_send_mail (arguments, data, retval);
 	} else if (g_ascii_strcasecmp(method, MODEST_DBUS_METHOD_MAIL_TO) == 0) {
 		return on_mail_to (arguments, data, retval);
 	} else if (g_ascii_strcasecmp(method, MODEST_DBUS_METHOD_OPEN_MESSAGE) == 0) {
 		return on_open_message (arguments, data, retval);
+	} else if (g_ascii_strcasecmp(method, MODEST_DBUS_METHOD_SEND_RECEIVE) == 0) {
+		return on_send_receive (arguments, data, retval);
+	} else if (g_ascii_strcasecmp(method, MODEST_DBUS_METHOD_COMPOSE_MAIL) == 0) {
+		return on_compose_mail (arguments, data, retval);
+	} else if (g_ascii_strcasecmp(method, MODEST_DBUS_METHOD_DELETE_MESSAGE) == 0) {
+		return on_delete_message (arguments,data, retval);
 	}
-	else
-		return OSSO_ERROR;
+	else { 
+		/* We need to return INVALID here so
+		 * osso is returning DBUS_HANDLER_RESULT_NOT_YET_HANDLED 
+		 * so our modest_dbus_req_filter can kick in!
+		 * */
+		return OSSO_INVALID;
+	}
+}
+
+#define SEARCH_HIT_DBUS_TYPE \
+	DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+	DBUS_TYPE_STRING_AS_STRING \
+	DBUS_TYPE_STRING_AS_STRING \
+	DBUS_TYPE_STRING_AS_STRING \
+	DBUS_TYPE_STRING_AS_STRING \
+	DBUS_TYPE_UINT64_AS_STRING \
+	DBUS_TYPE_BOOLEAN_AS_STRING \
+	DBUS_TYPE_BOOLEAN_AS_STRING \
+	DBUS_TYPE_INT64_AS_STRING \
+	DBUS_STRUCT_END_CHAR_AS_STRING
+
+static DBusMessage *
+search_result_to_messsage (DBusMessage *reply,
+			   GList       *hits)
+{
+	DBusMessageIter iter;
+	DBusMessageIter array_iter;
+	GList          *hit_iter;
+
+	dbus_message_iter_init_append (reply, &iter); 
+	dbus_message_iter_open_container (&iter,
+					  DBUS_TYPE_ARRAY,
+					  SEARCH_HIT_DBUS_TYPE,
+					  &array_iter); 
+
+	for (hit_iter = hits; hit_iter; hit_iter = hit_iter->next) {
+		DBusMessageIter  struct_iter;
+		ModestSearchHit *hit;
+		char            *msg_url;
+		const char      *subject;
+		const char      *folder;
+		const char      *sender;
+		guint64          size;
+		gboolean         has_attachment;
+		gboolean         is_unread;
+		gint64           ts;
+
+		hit = (ModestSearchHit *) hit_iter->data;
+
+		msg_url = hit->msgid;
+		subject = hit->subject;
+		folder  = hit->folder;
+		sender  = hit->sender;
+		size           = hit->msize;
+		has_attachment = hit->has_attachment;
+		is_unread      = hit->is_unread;
+		ts             = hit->timestamp;
+
+		g_debug ("Adding hit: %s", msg_url);	
+		
+		dbus_message_iter_open_container (&array_iter,
+						  DBUS_TYPE_STRUCT,
+						  NULL,
+						  &struct_iter);
+
+   		dbus_message_iter_append_basic (&struct_iter,
+						DBUS_TYPE_STRING,
+						&msg_url);
+
+		dbus_message_iter_append_basic (&struct_iter,
+						DBUS_TYPE_STRING,
+						&subject); 
+
+		dbus_message_iter_append_basic (&struct_iter,
+						DBUS_TYPE_STRING,
+						&folder);
+
+		dbus_message_iter_append_basic (&struct_iter,
+						DBUS_TYPE_STRING,
+						&sender);
+
+		dbus_message_iter_append_basic (&struct_iter,
+						DBUS_TYPE_UINT64,
+						&size);
+
+		dbus_message_iter_append_basic (&struct_iter,
+						DBUS_TYPE_BOOLEAN,
+						&has_attachment);
+
+		dbus_message_iter_append_basic (&struct_iter,
+						DBUS_TYPE_BOOLEAN,
+						&is_unread);
+		
+		dbus_message_iter_append_basic (&struct_iter,
+						DBUS_TYPE_INT64,
+						&ts);
+
+		dbus_message_iter_close_container (&array_iter,
+						   &struct_iter); 
+
+		g_free (hit->msgid);
+		g_free (hit->subject);
+		g_free (hit->folder);
+		g_free (hit->sender);
+
+		g_slice_free (ModestSearchHit, hit);
+	}
+
+	dbus_message_iter_close_container (&iter, &array_iter);
+
+	return reply;
+}
+
+DBusHandlerResult
+modest_dbus_req_filter (DBusConnection *con,
+			DBusMessage    *message,
+			void           *user_data)
+{
+	gboolean  handled = FALSE;
+  	DBusError error;
+
+	if (dbus_message_is_method_call (message,
+					 MODEST_DBUS_IFACE,
+					 MODEST_DBUS_METHOD_SEARCH)) {
+		ModestDBusSearchFlags dbus_flags;
+		ModestSearch  search;
+		DBusMessage  *reply = NULL;
+		dbus_bool_t  res;
+		dbus_int64_t sd_v;
+		dbus_int64_t ed_v;
+		dbus_int32_t flags_v;
+		dbus_uint32_t serial;
+		dbus_uint32_t size_v;
+		char *folder;
+		char *query;
+		time_t start_date;
+		time_t end_date;
+		GList *hits;
+
+		handled = TRUE;
+
+		dbus_error_init (&error);
+
+		sd_v = ed_v = 0;
+		flags_v = 0;
+
+		res = dbus_message_get_args (message,
+					     &error,
+					     DBUS_TYPE_STRING, &query,
+					     DBUS_TYPE_STRING, &folder,
+					     DBUS_TYPE_INT64, &sd_v,
+					     DBUS_TYPE_INT64, &ed_v,
+					     DBUS_TYPE_INT32, &flags_v,
+					     DBUS_TYPE_UINT32, &size_v,
+					     DBUS_TYPE_INVALID);
+		
+		dbus_flags = (ModestDBusSearchFlags) flags_v;
+		start_date = (time_t) sd_v;
+		end_date = (time_t) ed_v;
+
+		memset (&search, 0, sizeof (search));
+#ifdef MODEST_HAVE_OGS
+		search.query  = query;
+#endif
+		search.before = start_date;
+		search.after  = end_date;
+		search.flags  = 0;
+
+		if (dbus_flags & MODEST_DBUS_SEARCH_SUBJECT) {
+			search.flags |= MODEST_SEARCH_SUBJECT;
+			search.subject = query;
+		}
+
+		if (dbus_flags & MODEST_DBUS_SEARCH_SENDER) {
+			search.flags |=  MODEST_SEARCH_SENDER;
+			search.from = query;
+		}
+
+		if (dbus_flags & MODEST_DBUS_SEARCH_RECIPIENT) {
+			search.flags |= MODEST_SEARCH_RECIPIENT; 
+			search.recipient = query;
+		}
+
+		if (dbus_flags & MODEST_DBUS_SEARCH_BODY) {
+			search.flags |=  MODEST_SEARCH_BODY; 
+			search.subject = query;
+		}
+
+		if (sd_v > 0) {
+			search.flags |= MODEST_SEARCH_BEFORE;
+			search.before = start_date;
+		}
+
+		if (ed_v > 0) {
+			search.flags |= MODEST_SEARCH_AFTER;
+			search.after = end_date;
+		}
+
+		if (size_v > 0) {
+			search.flags |= MODEST_SEARCH_SIZE;
+			search.minsize = size_v;
+		}
+
+#ifdef MODEST_HAVE_OGS
+		search.flags |= MODEST_SEARCH_USE_OGS;
+		g_debug ("Starting search for %s", search.query);
+#endif
+		hits = modest_search_all_accounts (&search);
+
+		reply = dbus_message_new_method_return (message);
+
+		search_result_to_messsage (reply, hits);
+
+		if (reply == NULL) {
+			g_warning ("Could not create reply");
+		}
+
+		if (reply) {
+			dbus_connection_send (con, reply, &serial);
+	    		dbus_connection_flush (con);
+	    		dbus_message_unref (reply);
+		}
+
+		g_list_free (hits);
+
+	}
+	
+
+	return (handled ? 
+		DBUS_HANDLER_RESULT_HANDLED :
+		DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 }
 
 void
 modest_osso_cb_hw_state_handler(osso_hw_state_t *state, gpointer data)
 {
-    printf("%s()\n", __PRETTY_FUNCTION__);
+	/* TODO? */
+    /* printf("%s()\n", __PRETTY_FUNCTION__); */
 
     if(state->system_inactivity_ind)
     {
@@ -441,5 +1039,5 @@ modest_osso_cb_hw_state_handler(osso_hw_state_t *state, gpointer data)
     
     }
 
-    printf("debug: %s(): return\n", __PRETTY_FUNCTION__);
+    /* printf("debug: %s(): return\n", __PRETTY_FUNCTION__); */
 }