aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--doc/reference/libeutil/libeutil-sections.txt6
-rw-r--r--e-util/e-photo-cache.c923
-rw-r--r--e-util/e-photo-cache.h15
-rw-r--r--mail/e-mail-reader.c4
4 files changed, 665 insertions, 283 deletions
diff --git a/doc/reference/libeutil/libeutil-sections.txt b/doc/reference/libeutil/libeutil-sections.txt
index 49420677c4..71174e3db2 100644
--- a/doc/reference/libeutil/libeutil-sections.txt
+++ b/doc/reference/libeutil/libeutil-sections.txt
@@ -2489,10 +2489,14 @@ e_passwords_ask_password
EPhotoCache
e_photo_cache_new
e_photo_cache_ref_client_cache
+e_photo_cache_add_photo_source
+e_photo_cache_list_photo_sources
+e_photo_cache_remove_photo_source
+e_photo_cache_add_photo
+e_photo_cache_remove_photo
e_photo_cache_get_photo_sync
e_photo_cache_get_photo
e_photo_cache_get_photo_finish
-e_photo_cache_remove
<SUBSECTION Standard>
E_PHOTO_CACHE
E_IS_PHOTO_CACHE
diff --git a/e-util/e-photo-cache.c b/e-util/e-photo-cache.c
index 9ea0cb7ab2..42bad99eb6 100644
--- a/e-util/e-photo-cache.c
+++ b/e-util/e-photo-cache.c
@@ -21,12 +21,11 @@
* @include: e-util/e-util.h
* @short_description: Search for photos by email address
*
- * #EPhotoCache helps search for contact photo or logo images associated
- * with an email address.
+ * #EPhotoCache finds photos associated with an email address.
*
- * A limited internal cache is employed to speed up searches for recently
- * searched email addresses. The exact caching semantics are private and
- * subject to change.
+ * A limited internal cache is employed to speed up frequently searched
+ * email addresses. The exact caching semantics are private and subject
+ * to change.
**/
#include "e-photo-cache.h"
@@ -34,37 +33,73 @@
#include <string.h>
#include <libebackend/libebackend.h>
+#include <e-util/e-data-capture.h>
+
#define E_PHOTO_CACHE_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE \
((obj), E_TYPE_PHOTO_CACHE, EPhotoCachePrivate))
+/* How long (in seconds) to hold out for a hit from the highest
+ * priority photo source, after which we settle for what we have. */
+#define ASYNC_TIMEOUT_SECONDS 3.0
+
/* How many email addresses we track at once, regardless of whether
* the email address has a photo. As new cache entries are added, we
* discard the least recently accessed entries to keep the cache size
* within the limit. */
#define MAX_CACHE_SIZE 20
+#define ERROR_IS_CANCELLED(error) \
+ (g_error_matches ((error), G_IO_ERROR, G_IO_ERROR_CANCELLED))
+
typedef struct _AsyncContext AsyncContext;
+typedef struct _AsyncSubtask AsyncSubtask;
+typedef struct _DataCaptureClosure DataCaptureClosure;
typedef struct _PhotoData PhotoData;
struct _EPhotoCachePrivate {
EClientCache *client_cache;
+ GMainContext *main_context;
GHashTable *photo_ht;
GQueue photo_ht_keys;
GMutex photo_ht_lock;
+
+ GHashTable *sources_ht;
+ GMutex sources_ht_lock;
};
struct _AsyncContext {
+ GMutex lock;
+ GTimer *timer;
+ GHashTable *subtasks;
+ GQueue results;
+ GInputStream *stream;
+ GConverter *data_capture;
+
+ GCancellable *cancellable;
+ gulong cancelled_handler_id;
+};
+
+struct _AsyncSubtask {
+ volatile gint ref_count;
+ EPhotoSource *photo_source;
+ GSimpleAsyncResult *simple;
+ GCancellable *cancellable;
+ GInputStream *stream;
+ gint priority;
+ GError *error;
+};
+
+struct _DataCaptureClosure {
+ GWeakRef photo_cache;
gchar *email_address;
- GInputStream *input_stream;
};
struct _PhotoData {
volatile gint ref_count;
GMutex lock;
- EContactPhoto *photo;
- gboolean photo_is_set;
+ GBytes *bytes;
};
enum {
@@ -72,6 +107,9 @@ enum {
PROP_CLIENT_CACHE
};
+/* Forward Declarations */
+static void async_context_cancel_subtasks (AsyncContext *async_context);
+
G_DEFINE_TYPE_WITH_CODE (
EPhotoCache,
e_photo_cache,
@@ -79,27 +117,296 @@ G_DEFINE_TYPE_WITH_CODE (
G_IMPLEMENT_INTERFACE (
E_TYPE_EXTENSIBLE, NULL))
+static AsyncSubtask *
+async_subtask_new (EPhotoSource *photo_source,
+ GSimpleAsyncResult *simple)
+{
+ AsyncSubtask *async_subtask;
+
+ async_subtask = g_slice_new0 (AsyncSubtask);
+ async_subtask->ref_count = 1;
+ async_subtask->photo_source = g_object_ref (photo_source);
+ async_subtask->simple = g_object_ref (simple);
+ async_subtask->cancellable = g_cancellable_new ();
+ async_subtask->priority = G_PRIORITY_DEFAULT;
+
+ return async_subtask;
+}
+
+static AsyncSubtask *
+async_subtask_ref (AsyncSubtask *async_subtask)
+{
+ g_return_val_if_fail (async_subtask != NULL, NULL);
+ g_return_val_if_fail (async_subtask->ref_count > 0, NULL);
+
+ g_atomic_int_inc (&async_subtask->ref_count);
+
+ return async_subtask;
+}
+
+static void
+async_subtask_unref (AsyncSubtask *async_subtask)
+{
+ g_return_if_fail (async_subtask != NULL);
+ g_return_if_fail (async_subtask->ref_count > 0);
+
+ if (g_atomic_int_dec_and_test (&async_subtask->ref_count)) {
+
+ /* Ignore cancellations. */
+ if (ERROR_IS_CANCELLED (async_subtask->error))
+ g_clear_error (&async_subtask->error);
+
+ /* Leave a breadcrumb on the console
+ * about unpropagated subtask errors. */
+ if (async_subtask->error != NULL) {
+ g_warning (
+ "%s: Unpropagated error in %s subtask: %s",
+ __FILE__,
+ G_OBJECT_TYPE_NAME (
+ async_subtask->photo_source),
+ async_subtask->error->message);
+ g_error_free (async_subtask->error);
+ }
+
+ g_clear_object (&async_subtask->photo_source);
+ g_clear_object (&async_subtask->simple);
+ g_clear_object (&async_subtask->cancellable);
+ g_clear_object (&async_subtask->stream);
+
+ g_slice_free (AsyncSubtask, async_subtask);
+ }
+}
+
+static void
+async_subtask_cancel (AsyncSubtask *async_subtask)
+{
+ g_return_if_fail (async_subtask != NULL);
+
+ g_cancellable_cancel (async_subtask->cancellable);
+}
+
+static gint
+async_subtask_compare (gconstpointer a,
+ gconstpointer b)
+{
+ const AsyncSubtask *subtask_a = a;
+ const AsyncSubtask *subtask_b = b;
+
+ /* Without error is always less than with error. */
+
+ if (subtask_a->error != NULL && subtask_b->error != NULL)
+ return 0;
+
+ if (subtask_a->error == NULL && subtask_b->error != NULL)
+ return -1;
+
+ if (subtask_a->error != NULL && subtask_b->error == NULL)
+ return 1;
+
+ if (subtask_a->priority == subtask_b->priority)
+ return 0;
+
+ return (subtask_a->priority < subtask_b->priority) ? -1 : 1;
+}
+
+static void
+async_subtask_complete (AsyncSubtask *async_subtask)
+{
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ gboolean cancel_subtasks = FALSE;
+ gdouble seconds_elapsed;
+
+ simple = async_subtask->simple;
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ g_mutex_lock (&async_context->lock);
+
+ seconds_elapsed = g_timer_elapsed (async_context->timer, NULL);
+
+ /* Discard successfully completed subtasks with no match found.
+ * Keep failed subtasks around so we have a GError to propagate
+ * if we need one, but those go on the end of the queue. */
+
+ if (async_subtask->stream != NULL) {
+ g_queue_insert_sorted (
+ &async_context->results,
+ async_subtask_ref (async_subtask),
+ (GCompareDataFunc) async_subtask_compare,
+ NULL);
+
+ /* If enough seconds have elapsed, just take the highest
+ * priority input stream we have. Cancel the unfinished
+ * subtasks and let them complete with an error. */
+ if (seconds_elapsed > ASYNC_TIMEOUT_SECONDS)
+ cancel_subtasks = TRUE;
+
+ } else if (async_subtask->error != NULL) {
+ g_queue_push_tail (
+ &async_context->results,
+ async_subtask_ref (async_subtask));
+ }
+
+ g_hash_table_remove (async_context->subtasks, async_subtask);
+
+ if (g_hash_table_size (async_context->subtasks) > 0) {
+ /* Let the remaining subtasks finish. */
+ goto exit;
+ }
+
+ /* The queue should be ordered now such that subtasks
+ * with input streams are before subtasks with errors.
+ * So just evaluate the first subtask on the queue. */
+
+ async_subtask = g_queue_pop_head (&async_context->results);
+
+ if (async_subtask != NULL) {
+ if (async_subtask->stream != NULL) {
+ async_context->stream =
+ g_converter_input_stream_new (
+ async_subtask->stream,
+ async_context->data_capture);
+ }
+
+ if (async_subtask->error != NULL) {
+ g_simple_async_result_take_error (
+ simple, async_subtask->error);
+ async_subtask->error = NULL;
+ }
+
+ async_subtask_unref (async_subtask);
+ }
+
+ g_simple_async_result_complete_in_idle (simple);
+
+exit:
+ g_mutex_unlock (&async_context->lock);
+
+ if (cancel_subtasks) {
+ /* Call this after the mutex is unlocked. */
+ async_context_cancel_subtasks (async_context);
+ }
+}
+
+static void
+async_context_cancelled_cb (GCancellable *cancellable,
+ AsyncContext *async_context)
+{
+ async_context_cancel_subtasks (async_context);
+}
+
+static AsyncContext *
+async_context_new (EDataCapture *data_capture,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+
+ async_context = g_slice_new0 (AsyncContext);
+ g_mutex_init (&async_context->lock);
+ async_context->timer = g_timer_new ();
+
+ async_context->subtasks = g_hash_table_new_full (
+ (GHashFunc) g_direct_hash,
+ (GEqualFunc) g_direct_equal,
+ (GDestroyNotify) async_subtask_unref,
+ (GDestroyNotify) NULL);
+
+ async_context->data_capture = g_object_ref (data_capture);
+
+ if (G_IS_CANCELLABLE (cancellable)) {
+ gulong handler_id;
+
+ async_context->cancellable = g_object_ref (cancellable);
+
+ handler_id = g_cancellable_connect (
+ async_context->cancellable,
+ G_CALLBACK (async_context_cancelled_cb),
+ async_context,
+ (GDestroyNotify) NULL);
+ async_context->cancelled_handler_id = handler_id;
+ }
+
+ return async_context;
+}
+
static void
async_context_free (AsyncContext *async_context)
{
- g_free (async_context->email_address);
+ /* Do this first so the callback won't fire
+ * while we're dismantling the AsyncContext. */
+ if (async_context->cancelled_handler_id > 0)
+ g_cancellable_disconnect (
+ async_context->cancellable,
+ async_context->cancelled_handler_id);
+
+ g_mutex_clear (&async_context->lock);
+ g_timer_destroy (async_context->timer);
+
+ g_hash_table_destroy (async_context->subtasks);
- if (async_context->input_stream != NULL)
- g_object_unref (async_context->input_stream);
+ g_clear_object (&async_context->stream);
+ g_clear_object (&async_context->data_capture);
+ g_clear_object (&async_context->cancellable);
g_slice_free (AsyncContext, async_context);
}
+static void
+async_context_cancel_subtasks (AsyncContext *async_context)
+{
+ GQueue queue;
+ AsyncSubtask *async_subtask;
+
+ /* Copy subtasks to a secondary GQueue to avoid invoking
+ * "cancelled" signal handlers while the mutex is locked. */
+ g_mutex_lock (&async_context->lock);
+ queue.head = g_hash_table_get_keys (async_context->subtasks);
+ queue.tail = g_list_last (queue.head);
+ queue.length = g_list_length (queue.head);
+ g_queue_foreach (&queue, (GFunc) async_subtask_ref, NULL);
+ g_mutex_unlock (&async_context->lock);
+
+ /* Cancel all subtasks. */
+ while ((async_subtask = g_queue_pop_head (&queue)) != NULL) {
+ async_subtask_cancel (async_subtask);
+ async_subtask_unref (async_subtask);
+ }
+}
+
+static DataCaptureClosure *
+data_capture_closure_new (EPhotoCache *photo_cache,
+ const gchar *email_address)
+{
+ DataCaptureClosure *closure;
+
+ closure = g_slice_new0 (DataCaptureClosure);
+ g_weak_ref_set (&closure->photo_cache, photo_cache);
+ closure->email_address = g_strdup (email_address);
+
+ return closure;
+}
+
+static void
+data_capture_closure_free (DataCaptureClosure *closure)
+{
+ g_weak_ref_set (&closure->photo_cache, NULL);
+ g_free (closure->email_address);
+
+ g_slice_free (DataCaptureClosure, closure);
+}
+
static PhotoData *
-photo_data_new (void)
+photo_data_new (GBytes *bytes)
{
PhotoData *photo_data;
photo_data = g_slice_new0 (PhotoData);
photo_data->ref_count = 1;
-
g_mutex_init (&photo_data->lock);
+ if (bytes != NULL)
+ photo_data->bytes = g_bytes_ref (bytes);
+
return photo_data;
}
@@ -121,52 +428,41 @@ photo_data_unref (PhotoData *photo_data)
g_return_if_fail (photo_data->ref_count > 0);
if (g_atomic_int_dec_and_test (&photo_data->ref_count)) {
- if (photo_data->photo != NULL)
- e_contact_photo_free (photo_data->photo);
-
g_mutex_clear (&photo_data->lock);
-
+ if (photo_data->bytes != NULL)
+ g_bytes_unref (photo_data->bytes);
g_slice_free (PhotoData, photo_data);
}
}
-static gboolean
-photo_data_dup_photo (PhotoData *photo_data,
- EContactPhoto **out_photo)
+static GBytes *
+photo_data_ref_bytes (PhotoData *photo_data)
{
- gboolean photo_is_set;
-
- g_return_val_if_fail (out_photo != NULL, FALSE);
+ GBytes *bytes = NULL;
g_mutex_lock (&photo_data->lock);
- if (photo_data->photo != NULL)
- *out_photo = e_contact_photo_copy (photo_data->photo);
- else
- *out_photo = NULL;
-
- photo_is_set = photo_data->photo_is_set;
+ if (photo_data->bytes != NULL)
+ bytes = g_bytes_ref (photo_data->bytes);
g_mutex_unlock (&photo_data->lock);
- return photo_is_set;
+ return bytes;
}
static void
-photo_data_set_photo (PhotoData *photo_data,
- EContactPhoto *photo)
+photo_data_set_bytes (PhotoData *photo_data,
+ GBytes *bytes)
{
g_mutex_lock (&photo_data->lock);
- if (photo_data->photo != NULL) {
- e_contact_photo_free (photo_data->photo);
- photo_data->photo = NULL;
+ if (photo_data->bytes != NULL) {
+ g_bytes_unref (photo_data->bytes);
+ photo_data->bytes = NULL;
}
- if (photo != NULL)
- photo_data->photo = e_contact_photo_copy (photo);
-
- photo_data->photo_is_set = TRUE;
+ if (bytes != NULL)
+ photo_data->bytes = g_bytes_ref (bytes);
g_mutex_unlock (&photo_data->lock);
}
@@ -184,16 +480,17 @@ photo_ht_normalize_key (const gchar *email_address)
return collation_key;
}
-static PhotoData *
-photo_ht_lookup (EPhotoCache *photo_cache,
- const gchar *email_address)
+static void
+photo_ht_insert (EPhotoCache *photo_cache,
+ const gchar *email_address,
+ GBytes *bytes)
{
GHashTable *photo_ht;
GQueue *photo_ht_keys;
PhotoData *photo_data;
gchar *key;
- g_return_val_if_fail (email_address != NULL, NULL);
+ g_return_if_fail (email_address != NULL);
photo_ht = photo_cache->priv->photo_ht;
photo_ht_keys = &photo_cache->priv->photo_ht_keys;
@@ -207,7 +504,10 @@ photo_ht_lookup (EPhotoCache *photo_cache,
if (photo_data != NULL) {
GList *link;
- photo_data_ref (photo_data);
+ /* Replace the old photo data if we have new photo
+ * data, otherwise leave the old photo data alone. */
+ if (bytes != NULL)
+ photo_data_set_bytes (photo_data, bytes);
/* Move the key to the head of the MRU queue. */
link = g_queue_find_custom (
@@ -218,7 +518,7 @@ photo_ht_lookup (EPhotoCache *photo_cache,
g_queue_push_head_link (photo_ht_keys, link);
}
} else {
- photo_data = photo_data_new ();
+ photo_data = photo_data_new (bytes);
g_hash_table_insert (
photo_ht, g_strdup (key),
@@ -235,6 +535,8 @@ photo_ht_lookup (EPhotoCache *photo_cache,
g_hash_table_remove (photo_ht, oldest_key);
g_free (oldest_key);
}
+
+ photo_data_unref (photo_data);
}
/* Hash table and queue sizes should be equal at all times. */
@@ -245,8 +547,48 @@ photo_ht_lookup (EPhotoCache *photo_cache,
g_mutex_unlock (&photo_cache->priv->photo_ht_lock);
g_free (key);
+}
- return photo_data;
+static gboolean
+photo_ht_lookup (EPhotoCache *photo_cache,
+ const gchar *email_address,
+ GInputStream **out_stream)
+{
+ GHashTable *photo_ht;
+ PhotoData *photo_data;
+ gboolean found = FALSE;
+ gchar *key;
+
+ g_return_val_if_fail (email_address != NULL, FALSE);
+ g_return_val_if_fail (out_stream != NULL, FALSE);
+
+ photo_ht = photo_cache->priv->photo_ht;
+
+ key = photo_ht_normalize_key (email_address);
+
+ g_mutex_lock (&photo_cache->priv->photo_ht_lock);
+
+ photo_data = g_hash_table_lookup (photo_ht, key);
+
+ if (photo_data != NULL) {
+ GBytes *bytes;
+
+ bytes = photo_data_ref_bytes (photo_data);
+ if (bytes != NULL) {
+ *out_stream =
+ g_memory_input_stream_new_from_bytes (bytes);
+ g_bytes_unref (bytes);
+ } else {
+ *out_stream = NULL;
+ }
+ found = TRUE;
+ }
+
+ g_mutex_unlock (&photo_cache->priv->photo_ht_lock);
+
+ g_free (key);
+
+ return found;
}
static gboolean
@@ -311,140 +653,38 @@ photo_ht_remove_all (EPhotoCache *photo_cache)
g_mutex_unlock (&photo_cache->priv->photo_ht_lock);
}
-static EContactPhoto *
-photo_cache_extract_photo (EContact *contact)
-{
- EContactPhoto *photo;
-
- photo = e_contact_get (contact, E_CONTACT_PHOTO);
- if (photo == NULL)
- photo = e_contact_get (contact, E_CONTACT_LOGO);
-
- return photo;
-}
-
-static gboolean
-photo_cache_find_contacts (EPhotoCache *photo_cache,
- const gchar *email_address,
- GCancellable *cancellable,
- GQueue *out_contacts,
- GError **error)
+static void
+photo_cache_data_captured_cb (EDataCapture *data_capture,
+ GBytes *bytes,
+ DataCaptureClosure *closure)
{
- EClientCache *client_cache;
- ESourceRegistry *registry;
- EBookQuery *book_query;
- GList *list, *link;
- const gchar *extension_name;
- gchar *book_query_string;
- gboolean success = TRUE;
-
- book_query = e_book_query_field_test (
- E_CONTACT_EMAIL, E_BOOK_QUERY_IS, email_address);
- book_query_string = e_book_query_to_string (book_query);
- e_book_query_unref (book_query);
-
- client_cache = e_photo_cache_ref_client_cache (photo_cache);
- registry = e_client_cache_ref_registry (client_cache);
-
- extension_name = E_SOURCE_EXTENSION_ADDRESS_BOOK;
- list = e_source_registry_list_enabled (registry, extension_name);
-
- for (link = list; link != NULL; link = g_list_next (link)) {
- ESource *source = E_SOURCE (link->data);
- EClient *client;
- GSList *contact_list = NULL;
- GError *local_error = NULL;
-
- client = e_client_cache_get_client_sync (
- client_cache,
- source, extension_name,
- cancellable, &local_error);
-
- if (local_error != NULL) {
- g_warn_if_fail (client == NULL);
- if (g_queue_is_empty (out_contacts)) {
- g_propagate_error (error, local_error);
- success = FALSE;
- } else {
- /* Clear the error if we already
- * have matching contacts queued. */
- g_clear_error (&local_error);
- }
- break;
- }
-
- e_book_client_get_contacts_sync (
- E_BOOK_CLIENT (client), book_query_string,
- &contact_list, cancellable, &local_error);
-
- g_object_unref (client);
-
- if (local_error != NULL) {
- g_warn_if_fail (contact_list == NULL);
- if (g_queue_is_empty (out_contacts)) {
- g_propagate_error (error, local_error);
- success = FALSE;
- } else {
- /* Clear the error if we already
- * have matching contacts queued. */
- g_clear_error (&local_error);
- }
- break;
- }
+ EPhotoCache *photo_cache;
- while (contact_list != NULL) {
- EContact *contact;
+ photo_cache = g_weak_ref_get (&closure->photo_cache);
- /* Transfer ownership to queue. */
- contact = E_CONTACT (contact_list->data);
- g_queue_push_tail (out_contacts, contact);
-
- contact_list = g_slist_delete_link (
- contact_list, contact_list);
- }
+ if (photo_cache != NULL) {
+ e_photo_cache_add_photo (
+ photo_cache, closure->email_address, bytes);
+ g_object_unref (photo_cache);
}
-
- g_list_free_full (list, (GDestroyNotify) g_object_unref);
-
- g_object_unref (client_cache);
- g_object_unref (registry);
-
- g_free (book_query_string);
-
- return success;
}
-static GInputStream *
-photo_cache_new_stream_from_photo (EContactPhoto *photo,
- GCancellable *cancellable,
- GError **error)
+static void
+photo_cache_async_subtask_done_cb (GObject *source_object,
+ GAsyncResult *result,
+ gpointer user_data)
{
- GInputStream *stream = NULL;
+ AsyncSubtask *async_subtask = user_data;
- /* Stream takes ownership of the inlined data. */
- if (photo->type == E_CONTACT_PHOTO_TYPE_INLINED) {
- stream = g_memory_input_stream_new_from_data (
- photo->data.inlined.data,
- photo->data.inlined.length,
- (GDestroyNotify) g_free);
- photo->data.inlined.data = NULL;
- photo->data.inlined.length = 0;
+ e_photo_source_get_photo_finish (
+ E_PHOTO_SOURCE (source_object),
+ result,
+ &async_subtask->stream,
+ &async_subtask->priority,
+ &async_subtask->error);
- } else {
- GFileInputStream *file_stream;
- GFile *file;
-
- file = g_file_new_for_uri (photo->data.uri);
-
- /* XXX Return type should have been GInputStream. */
- file_stream = g_file_read (file, cancellable, error);
- if (file_stream != NULL)
- stream = G_INPUT_STREAM (file_stream);
-
- g_object_unref (file);
- }
-
- return stream;
+ async_subtask_complete (async_subtask);
+ async_subtask_unref (async_subtask);
}
static void
@@ -514,8 +754,13 @@ photo_cache_finalize (GObject *object)
priv = E_PHOTO_CACHE_GET_PRIVATE (object);
+ g_main_context_unref (priv->main_context);
+
g_hash_table_destroy (priv->photo_ht);
+ g_mutex_lock (&priv->photo_ht_lock);
+ g_mutex_lock (&priv->sources_ht_lock);
+
/* Chain up to parent's finalize() method. */
G_OBJECT_CLASS (e_photo_cache_parent_class)->finalize (object);
}
@@ -565,6 +810,7 @@ static void
e_photo_cache_init (EPhotoCache *photo_cache)
{
GHashTable *photo_ht;
+ GHashTable *sources_ht;
photo_ht = g_hash_table_new_full (
(GHashFunc) g_str_hash,
@@ -572,10 +818,19 @@ e_photo_cache_init (EPhotoCache *photo_cache)
(GDestroyNotify) g_free,
(GDestroyNotify) photo_data_unref);
+ sources_ht = g_hash_table_new_full (
+ (GHashFunc) g_direct_hash,
+ (GEqualFunc) g_direct_equal,
+ (GDestroyNotify) g_object_unref,
+ (GDestroyNotify) NULL);
+
photo_cache->priv = E_PHOTO_CACHE_GET_PRIVATE (photo_cache);
+ photo_cache->priv->main_context = g_main_context_ref_thread_default ();
photo_cache->priv->photo_ht = photo_ht;
+ photo_cache->priv->sources_ht = sources_ht;
g_mutex_init (&photo_cache->priv->photo_ht_lock);
+ g_mutex_init (&photo_cache->priv->sources_ht_lock);
}
/**
@@ -616,6 +871,146 @@ e_photo_cache_ref_client_cache (EPhotoCache *photo_cache)
}
/**
+ * e_photo_cache_add_photo_source:
+ * @photo_cache: an #EPhotoCache
+ * @photo_source: an #EPhotoSource
+ *
+ * Adds @photo_source as a potential source of photos.
+ **/
+void
+e_photo_cache_add_photo_source (EPhotoCache *photo_cache,
+ EPhotoSource *photo_source)
+{
+ GHashTable *sources_ht;
+
+ g_return_if_fail (E_IS_PHOTO_CACHE (photo_cache));
+ g_return_if_fail (E_IS_PHOTO_SOURCE (photo_source));
+
+ sources_ht = photo_cache->priv->sources_ht;
+
+ g_mutex_lock (&photo_cache->priv->sources_ht_lock);
+
+ g_hash_table_add (sources_ht, g_object_ref (photo_source));
+
+ g_mutex_unlock (&photo_cache->priv->sources_ht_lock);
+}
+
+/**
+ * e_photo_cache_list_photo_sources:
+ * @photo_cache: an #EPhotoCache
+ *
+ * Returns a list of photo sources for @photo_cache.
+ *
+ * The sources returned in the list are referenced for thread-safety.
+ * They must each be unreferenced with g_object_unref() when finished
+ * with them. Free the returned list itself with g_list_free().
+ *
+ * An easy way to free the list property in one step is as follows:
+ *
+ * |[
+ * g_list_free_full (list, g_object_unref);
+ * ]|
+ *
+ * Returns: a sorted list of photo sources
+ **/
+GList *
+e_photo_cache_list_photo_sources (EPhotoCache *photo_cache)
+{
+ GHashTable *sources_ht;
+ GList *list;
+
+ g_return_val_if_fail (E_IS_PHOTO_CACHE (photo_cache), NULL);
+
+ sources_ht = photo_cache->priv->sources_ht;
+
+ g_mutex_lock (&photo_cache->priv->sources_ht_lock);
+
+ list = g_hash_table_get_keys (sources_ht);
+ g_list_foreach (list, (GFunc) g_object_ref, NULL);
+
+ g_mutex_unlock (&photo_cache->priv->sources_ht_lock);
+
+ return list;
+}
+
+/**
+ * e_photo_cache_remove_photo_source:
+ * @photo_cache: an #EPhotoCache
+ * @photo_source: an #EPhotoSource
+ *
+ * Removes @photo_source as a potential source of photos.
+ *
+ * Returns: %TRUE if @photo_source was found and removed, %FALSE if not
+ **/
+gboolean
+e_photo_cache_remove_photo_source (EPhotoCache *photo_cache,
+ EPhotoSource *photo_source)
+{
+ GHashTable *sources_ht;
+ gboolean removed;
+
+ g_return_val_if_fail (E_IS_PHOTO_CACHE (photo_cache), FALSE);
+ g_return_val_if_fail (E_IS_PHOTO_SOURCE (photo_source), FALSE);
+
+ sources_ht = photo_cache->priv->sources_ht;
+
+ g_mutex_lock (&photo_cache->priv->sources_ht_lock);
+
+ removed = g_hash_table_remove (sources_ht, photo_source);
+
+ g_mutex_unlock (&photo_cache->priv->sources_ht_lock);
+
+ return removed;
+}
+
+/**
+ * e_photo_cache_add_photo:
+ * @photo_cache: an #EPhotoCache
+ * @email_address: an email address
+ * @bytes: a #GBytes containing photo data, or %NULL
+ *
+ * Adds a cache entry for @email_address, such that subsequent photo requests
+ * for @email_address will yield a #GMemoryInputStream loaded with @bytes
+ * without consulting available photo sources.
+ *
+ * The @bytes argument can also be %NULL to indicate no photo is available for
+ * @email_address. Subsequent photo requests for @email_address will yield no
+ * input stream.
+ *
+ * The entry may be removed without notice however, subject to @photo_cache's
+ * internal caching policy.
+ **/
+void
+e_photo_cache_add_photo (EPhotoCache *photo_cache,
+ const gchar *email_address,
+ GBytes *bytes)
+{
+ g_return_if_fail (E_IS_PHOTO_CACHE (photo_cache));
+ g_return_if_fail (email_address != NULL);
+
+ photo_ht_insert (photo_cache, email_address, bytes);
+}
+
+/**
+ * e_photo_cache_remove_photo:
+ * @photo_cache: an #EPhotoCache
+ * @email_address: an email address
+ *
+ * Removes the cache entry for @email_address, if such an entry exists.
+ *
+ * Returns: %TRUE if a cache entry was found and removed
+ **/
+gboolean
+e_photo_cache_remove_photo (EPhotoCache *photo_cache,
+ const gchar *email_address)
+{
+ g_return_val_if_fail (E_IS_PHOTO_CACHE (photo_cache), FALSE);
+ g_return_val_if_fail (email_address != NULL, FALSE);
+
+ return photo_ht_remove (photo_cache, email_address);
+}
+
+/**
* e_photo_cache_get_photo_sync:
* @photo_cache: an #EPhotoCache
* @email_address: an email address
@@ -623,8 +1018,8 @@ e_photo_cache_ref_client_cache (EPhotoCache *photo_cache)
* @out_stream: return location for a #GInputStream, or %NULL
* @error: return location for a #GError, or %NULL
*
- * Searches enabled address books for a contact photo or logo associated
- * with @email_address.
+ * Searches available photo sources for a photo associated with
+ * @email_address.
*
* If a match is found, a #GInputStream from which to read image data is
* returned through the @out_stream return location. If no match is found,
@@ -643,94 +1038,26 @@ e_photo_cache_get_photo_sync (EPhotoCache *photo_cache,
GInputStream **out_stream,
GError **error)
{
- EContactPhoto *photo = NULL;
- EClientCache *client_cache;
- GQueue queue = G_QUEUE_INIT;
- PhotoData *photo_data;
- gboolean success = TRUE;
-
- g_return_val_if_fail (E_IS_PHOTO_CACHE (photo_cache), FALSE);
- g_return_val_if_fail (email_address != NULL, FALSE);
-
- client_cache = e_photo_cache_ref_client_cache (photo_cache);
+ EAsyncClosure *closure;
+ GAsyncResult *result;
+ gboolean success;
- /* Try the cache first. */
- photo_data = photo_ht_lookup (photo_cache, email_address);
- if (photo_data_dup_photo (photo_data, &photo))
- goto exit;
-
- /* Find contacts with a matching email address. */
- success = photo_cache_find_contacts (
- photo_cache, email_address,
- cancellable, &queue, error);
- if (!success) {
- g_warn_if_fail (g_queue_is_empty (&queue));
- goto exit;
- }
+ closure = e_async_closure_new ();
- /* Extract the first available photo from contacts. */
- while (!g_queue_is_empty (&queue)) {
- EContact *contact;
+ e_photo_cache_get_photo (
+ photo_cache, email_address, cancellable,
+ e_async_closure_callback, closure);
- contact = g_queue_pop_head (&queue);
- if (photo == NULL)
- photo = photo_cache_extract_photo (contact);
- g_object_unref (contact);
- }
+ result = e_async_closure_wait (closure);
- /* Passing a NULL photo here is fine. We want to cache not
- * only the photo itself, but whether a photo was found for
- * this email address. */
- photo_data_set_photo (photo_data, photo);
+ success = e_photo_cache_get_photo_finish (
+ photo_cache, result, out_stream, error);
-exit:
- photo_data_unref (photo_data);
-
- g_object_unref (client_cache);
-
- /* Try opening an input stream to the photo data. */
- if (photo != NULL) {
- GInputStream *stream;
-
- stream = photo_cache_new_stream_from_photo (
- photo, cancellable, error);
-
- success = (stream != NULL);
-
- if (stream != NULL) {
- if (out_stream != NULL)
- *out_stream = g_object_ref (stream);
- g_object_unref (stream);
- }
-
- e_contact_photo_free (photo);
- }
+ e_async_closure_free (closure);
return success;
}
-/* Helper for e_photo_cache_get_photo() */
-static void
-photo_cache_get_photo_thread (GSimpleAsyncResult *simple,
- GObject *source_object,
- GCancellable *cancellable)
-{
- AsyncContext *async_context;
- GError *error = NULL;
-
- async_context = g_simple_async_result_get_op_res_gpointer (simple);
-
- e_photo_cache_get_photo_sync (
- E_PHOTO_CACHE (source_object),
- async_context->email_address,
- cancellable,
- &async_context->input_stream,
- &error);
-
- if (error != NULL)
- g_simple_async_result_take_error (simple, error);
-}
-
/**
* e_photo_cache_get_photo:
* @photo_cache: an #EPhotoCache
@@ -739,8 +1066,8 @@ photo_cache_get_photo_thread (GSimpleAsyncResult *simple,
* @callback: a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: data to pass to the callback function
*
- * Asynchronously searches enabled address books for a contact photo or logo
- * associated with @email_address.
+ * Asynchronously searches available photo sources for a photo associated
+ * with @email_address.
*
* When the operation is finished, @callback will be called. You can then
* call e_photo_cache_get_photo_finish() to get the result of the operation.
@@ -754,12 +1081,24 @@ e_photo_cache_get_photo (EPhotoCache *photo_cache,
{
GSimpleAsyncResult *simple;
AsyncContext *async_context;
+ EDataCapture *data_capture;
+ GInputStream *stream = NULL;
+ GList *list, *link;
g_return_if_fail (E_IS_PHOTO_CACHE (photo_cache));
g_return_if_fail (email_address != NULL);
- async_context = g_slice_new0 (AsyncContext);
- async_context->email_address = g_strdup (email_address);
+ /* This will be used to eavesdrop on the resulting input stream
+ * for the purpose of adding the photo data to the photo cache. */
+ data_capture = e_data_capture_new (photo_cache->priv->main_context);
+
+ g_signal_connect_data (
+ data_capture, "finished",
+ G_CALLBACK (photo_cache_data_captured_cb),
+ data_capture_closure_new (photo_cache, email_address),
+ (GClosureNotify) data_capture_closure_free, 0);
+
+ async_context = async_context_new (data_capture, cancellable);
simple = g_simple_async_result_new (
G_OBJECT (photo_cache), callback,
@@ -770,11 +1109,54 @@ e_photo_cache_get_photo (EPhotoCache *photo_cache,
g_simple_async_result_set_op_res_gpointer (
simple, async_context, (GDestroyNotify) async_context_free);
- g_simple_async_result_run_in_thread (
- simple, photo_cache_get_photo_thread,
- G_PRIORITY_DEFAULT, cancellable);
+ /* Check if we have this email address already cached. */
+ if (photo_ht_lookup (photo_cache, email_address, &stream)) {
+ async_context->stream = stream; /* takes ownership */
+ g_simple_async_result_complete_in_idle (simple);
+ goto exit;
+ }
+
+ list = e_photo_cache_list_photo_sources (photo_cache);
+ if (list == NULL) {
+ g_simple_async_result_complete_in_idle (simple);
+ goto exit;
+ }
+
+ g_mutex_lock (&async_context->lock);
+
+ /* Dispatch a subtask for each photo source. */
+ for (link = list; link != NULL; link = g_list_next (link)) {
+ EPhotoSource *photo_source;
+ AsyncSubtask *async_subtask;
+
+ photo_source = E_PHOTO_SOURCE (link->data);
+ async_subtask = async_subtask_new (photo_source, simple);
+
+ g_hash_table_add (
+ async_context->subtasks,
+ async_subtask_ref (async_subtask));
+
+ e_photo_source_get_photo (
+ photo_source, email_address,
+ async_subtask->cancellable,
+ photo_cache_async_subtask_done_cb,
+ async_subtask_ref (async_subtask));
+
+ async_subtask_unref (async_subtask);
+ }
+
+ g_mutex_unlock (&async_context->lock);
+
+ g_list_free_full (list, (GDestroyNotify) g_object_unref);
+
+ /* Check if we were cancelled while dispatching subtasks. */
+ if (g_cancellable_is_cancelled (cancellable))
+ async_context_cancel_subtasks (async_context);
+
+exit:
g_object_unref (simple);
+ g_object_unref (data_capture);
}
/**
@@ -817,27 +1199,12 @@ e_photo_cache_get_photo_finish (EPhotoCache *photo_cache,
return FALSE;
if (out_stream != NULL) {
- *out_stream = async_context->input_stream;
- async_context->input_stream = NULL;
+ if (async_context->stream != NULL)
+ *out_stream = g_object_ref (async_context->stream);
+ else
+ *out_stream = NULL;
}
return TRUE;
}
-/**
- * e_photo_cache_remove:
- * @photo_cache: an #EPhotoCache
- * @email_address: an email address
- *
- * Removes the cache entry for @email_address, if such an entry exists.
- **/
-gboolean
-e_photo_cache_remove (EPhotoCache *photo_cache,
- const gchar *email_address)
-{
- g_return_val_if_fail (E_IS_PHOTO_CACHE (photo_cache), FALSE);
- g_return_val_if_fail (email_address != NULL, FALSE);
-
- return photo_ht_remove (photo_cache, email_address);
-}
-
diff --git a/e-util/e-photo-cache.h b/e-util/e-photo-cache.h
index af44e2e3f1..0c310080e7 100644
--- a/e-util/e-photo-cache.h
+++ b/e-util/e-photo-cache.h
@@ -25,6 +25,7 @@
#include <libebook/libebook.h>
#include <e-util/e-client-cache.h>
+#include <e-util/e-photo-source.h>
/* Standard GObject macros */
#define E_TYPE_PHOTO_CACHE \
@@ -69,6 +70,18 @@ struct _EPhotoCacheClass {
GType e_photo_cache_get_type (void) G_GNUC_CONST;
EPhotoCache * e_photo_cache_new (EClientCache *client_cache);
EClientCache * e_photo_cache_ref_client_cache (EPhotoCache *photo_cache);
+void e_photo_cache_add_photo_source (EPhotoCache *photo_cache,
+ EPhotoSource *photo_source);
+GList * e_photo_cache_list_photo_sources
+ (EPhotoCache *photo_cache);
+gboolean e_photo_cache_remove_photo_source
+ (EPhotoCache *photo_cache,
+ EPhotoSource *photo_source);
+void e_photo_cache_add_photo (EPhotoCache *photo_cache,
+ const gchar *email_address,
+ GBytes *bytes);
+gboolean e_photo_cache_remove_photo (EPhotoCache *photo_cache,
+ const gchar *email_address);
gboolean e_photo_cache_get_photo_sync (EPhotoCache *photo_cache,
const gchar *email_address,
GCancellable *cancellable,
@@ -83,8 +96,6 @@ gboolean e_photo_cache_get_photo_finish (EPhotoCache *photo_cache,
GAsyncResult *result,
GInputStream **out_stream,
GError **error);
-gboolean e_photo_cache_remove (EPhotoCache *photo_cache,
- const gchar *email_address);
G_END_DECLS
diff --git a/mail/e-mail-reader.c b/mail/e-mail-reader.c
index 1556481d62..e36b1f745b 100644
--- a/mail/e-mail-reader.c
+++ b/mail/e-mail-reader.c
@@ -199,7 +199,7 @@ action_mail_add_sender_cb (GtkAction *action,
photo_cache = e_mail_ui_session_get_photo_cache (
E_MAIL_UI_SESSION (session));
camel_internet_address_get (cia, 0, NULL, &address_only);
- e_photo_cache_remove (photo_cache, address_only);
+ e_photo_cache_remove_photo (photo_cache, address_only);
}
g_object_unref (cia);
@@ -261,7 +261,7 @@ action_add_to_address_book_cb (GtkAction *action,
photo_cache = e_mail_ui_session_get_photo_cache (
E_MAIL_UI_SESSION (session));
camel_internet_address_get (cia, 0, NULL, &address_only);
- e_photo_cache_remove (photo_cache, address_only);
+ e_photo_cache_remove_photo (photo_cache, address_only);
g_object_unref (cia);