ECalBackend

ECalBackend

Synopsis

struct              ECalBackend;
#define             CLIENT_BACKEND_PROPERTY_CAPABILITIES
#define             CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS
#define             CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS
#define             CAL_BACKEND_PROPERTY_DEFAULT_OBJECT
#define             CAL_BACKEND_PROPERTY_REVISION
icalcomponent_kind  e_cal_backend_get_kind              (ECalBackend *backend);
EDataCal *          e_cal_backend_ref_data_cal          (ECalBackend *backend);
void                e_cal_backend_set_data_cal          (ECalBackend *backend,
                                                         EDataCal *data_cal);
ESourceRegistry *   e_cal_backend_get_registry          (ECalBackend *backend);
gboolean            e_cal_backend_get_writable          (ECalBackend *backend);
void                e_cal_backend_set_writable          (ECalBackend *backend,
                                                         gboolean writable);
gboolean            e_cal_backend_is_opened             (ECalBackend *backend);
gboolean            e_cal_backend_is_readonly           (ECalBackend *backend);
const gchar *       e_cal_backend_get_cache_dir         (ECalBackend *backend);
gchar *             e_cal_backend_dup_cache_dir         (ECalBackend *backend);
void                e_cal_backend_set_cache_dir         (ECalBackend *backend,
                                                         const gchar *cache_dir);
gchar *             e_cal_backend_create_cache_filename (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *filename,
                                                         gint fileindex);
void                e_cal_backend_add_view              (ECalBackend *backend,
                                                         EDataCalView *view);
void                e_cal_backend_remove_view           (ECalBackend *backend,
                                                         EDataCalView *view);
GList *             e_cal_backend_list_views            (ECalBackend *backend);
gchar *             e_cal_backend_get_backend_property  (ECalBackend *backend,
                                                         const gchar *prop_name);
gboolean            e_cal_backend_open_sync             (ECalBackend *backend,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_open                  (ECalBackend *backend,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_open_finish           (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_cal_backend_refresh_sync          (ECalBackend *backend,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_refresh               (ECalBackend *backend,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_refresh_finish        (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gchar *             e_cal_backend_get_object_sync       (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_get_object            (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gchar *             e_cal_backend_get_object_finish     (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_cal_backend_get_object_list_sync  (ECalBackend *backend,
                                                         const gchar *query,
                                                         GQueue *out_objects,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_get_object_list       (ECalBackend *backend,
                                                         const gchar *query,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_get_object_list_finish
                                                        (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GQueue *out_objects,
                                                         GError **error);
gboolean            e_cal_backend_get_free_busy_sync    (ECalBackend *backend,
                                                         time_t start,
                                                         time_t end,
                                                         const gchar * const *users,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_get_free_busy         (ECalBackend *backend,
                                                         time_t start,
                                                         time_t end,
                                                         const gchar * const *users,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_get_free_busy_finish  (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_cal_backend_create_objects_sync   (ECalBackend *backend,
                                                         const gchar * const *calobjs,
                                                         GQueue *out_uids,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_create_objects        (ECalBackend *backend,
                                                         const gchar * const *calobjs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_create_objects_finish (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GQueue *out_uids,
                                                         GError **error);
gboolean            e_cal_backend_modify_objects_sync   (ECalBackend *backend,
                                                         const gchar * const *calobjs,
                                                         ECalObjModType mod,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_modify_objects        (ECalBackend *backend,
                                                         const gchar * const *calobjs,
                                                         ECalObjModType mod,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_modify_objects_finish (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_cal_backend_remove_objects_sync   (ECalBackend *backend,
                                                         GList *component_ids,
                                                         ECalObjModType mod,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_remove_objects        (ECalBackend *backend,
                                                         GList *component_ids,
                                                         ECalObjModType mod,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_remove_objects_finish (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_cal_backend_receive_objects_sync  (ECalBackend *backend,
                                                         const gchar *calobj,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_receive_objects       (ECalBackend *backend,
                                                         const gchar *calobj,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_receive_objects_finish
                                                        (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gchar *             e_cal_backend_send_objects_sync     (ECalBackend *backend,
                                                         const gchar *calobj,
                                                         GQueue *out_users,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_send_objects          (ECalBackend *backend,
                                                         const gchar *calobj,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gchar *             e_cal_backend_send_objects_finish   (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GQueue *out_users,
                                                         GError **error);
gboolean            e_cal_backend_get_attachment_uris_sync
                                                        (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         GQueue *out_attachment_uris,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_get_attachment_uris   (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_get_attachment_uris_finish
                                                        (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GQueue *out_attachment_uris,
                                                         GError **error);
gboolean            e_cal_backend_discard_alarm_sync    (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         const gchar *alarm_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_discard_alarm         (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         const gchar *alarm_uid,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_discard_alarm_finish  (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gchar *             e_cal_backend_get_timezone_sync     (ECalBackend *backend,
                                                         const gchar *tzid,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_get_timezone          (ECalBackend *backend,
                                                         const gchar *tzid,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gchar *             e_cal_backend_get_timezone_finish   (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_cal_backend_add_timezone_sync     (ECalBackend *backend,
                                                         const gchar *tzobject,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_cal_backend_add_timezone          (ECalBackend *backend,
                                                         const gchar *tzobject,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_cal_backend_add_timezone_finish   (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);
void                e_cal_backend_start_view            (ECalBackend *backend,
                                                         EDataCalView *view);
void                e_cal_backend_stop_view             (ECalBackend *backend,
                                                         EDataCalView *view);
void                e_cal_backend_notify_component_created
                                                        (ECalBackend *backend,
                                                         ECalComponent *component);
void                e_cal_backend_notify_component_modified
                                                        (ECalBackend *backend,
                                                         ECalComponent *old_component,
                                                         ECalComponent *new_component);
void                e_cal_backend_notify_component_removed
                                                        (ECalBackend *backend,
                                                         const ECalComponentId *id,
                                                         ECalComponent *old_component,
                                                         ECalComponent *new_component);
void                e_cal_backend_notify_error          (ECalBackend *backend,
                                                         const gchar *message);
void                e_cal_backend_notify_property_changed
                                                        (ECalBackend *backend,
                                                         const gchar *prop_name,
                                                         const gchar *prop_value);
void                e_cal_backend_empty_cache           (ECalBackend *backend,
                                                         struct _ECalBackendCache *cache);

Object Hierarchy

  GObject
   +----EBackend
         +----ECalBackend
               +----ECalBackendSync

Implemented Interfaces

ECalBackend implements ETimezoneCache.

Properties

  "cache-dir"                gchar*                : Read / Write
  "kind"                     gulong                : Read / Write / Construct Only
  "registry"                 ESourceRegistry*      : Read / Write / Construct Only
  "writable"                 gboolean              : Read / Write

Signals

  "closed"                                         : Run Last
  "shutdown"                                       : Run Last

Description

Details

struct ECalBackend

struct ECalBackend;

CLIENT_BACKEND_PROPERTY_CAPABILITIES

#define CLIENT_BACKEND_PROPERTY_CAPABILITIES		"capabilities"

FIXME: Document me.

Since 3.2


CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS

#define CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS		"cal-email-address"

FIXME: Document me.

Since 3.2


CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS

#define CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS "alarm-email-address"

FIXME: Document me.

Since 3.2


CAL_BACKEND_PROPERTY_DEFAULT_OBJECT

#define CAL_BACKEND_PROPERTY_DEFAULT_OBJECT		"default-object"

FIXME: Document me.

Since 3.2


CAL_BACKEND_PROPERTY_REVISION

#define CAL_BACKEND_PROPERTY_REVISION			"revision"

The current overall revision string, this can be used as a quick check to see if data has changed at all since the last time the calendar revision was observed.

Since 3.4


e_cal_backend_get_kind ()

icalcomponent_kind  e_cal_backend_get_kind              (ECalBackend *backend);

Gets the kind of components the given backend stores.

backend :

an ECalBackend

Returns :

The kind of components for this backend.

e_cal_backend_ref_data_cal ()

EDataCal *          e_cal_backend_ref_data_cal          (ECalBackend *backend);

Returns the EDataCal for backend. The EDataCal is essentially the glue between incoming D-Bus requests and backend's native API.

An EDataCal should be set only once after backend is first created. If an EDataCal has not yet been set, the function returns NULL.

The returned EDataCal is referenced for thread-safety and must be unreferenced with g_object_unref() when finished with it.

backend :

an ECalBackend

Returns :

an EDataCal, or NULL

Since 3.10


e_cal_backend_set_data_cal ()

void                e_cal_backend_set_data_cal          (ECalBackend *backend,
                                                         EDataCal *data_cal);

Sets the EDataCal for backend. The EDataCal is essentially the glue between incoming D-Bus requests and backend's native API.

An EDataCal should be set only once after backend is first created.

backend :

an ECalBackend

data_cal :

an EDataCal

Since 3.10


e_cal_backend_get_registry ()

ESourceRegistry *   e_cal_backend_get_registry          (ECalBackend *backend);

Returns the data source registry to which "source" belongs.

backend :

an ECalBackend

Returns :

an ESourceRegistry

Since 3.6


e_cal_backend_get_writable ()

gboolean            e_cal_backend_get_writable          (ECalBackend *backend);

Returns whether backend will accept changes to its data content.

backend :

an ECalBackend

Returns :

whether backend is writable

Since 3.8


e_cal_backend_set_writable ()

void                e_cal_backend_set_writable          (ECalBackend *backend,
                                                         gboolean writable);

Sets whether backend will accept changes to its data content.

backend :

an ECalBackend

writable :

whether backend is writable

Since 3.8


e_cal_backend_is_opened ()

gboolean            e_cal_backend_is_opened             (ECalBackend *backend);

Checks if backend's storage has been opened (and authenticated, if necessary) and the backend itself is ready for accessing. This property is changed automatically within call of e_cal_backend_notify_opened().

backend :

an ECalBackend

Returns :

TRUE if fully opened, FALSE otherwise.

Since 3.2


e_cal_backend_is_readonly ()

gboolean            e_cal_backend_is_readonly           (ECalBackend *backend);

backend :

an ECalBackend

Returns :

Whether is backend read-only. This value is the last used in a call of e_cal_backend_notify_readonly().

Since 3.2


e_cal_backend_get_cache_dir ()

const gchar *       e_cal_backend_get_cache_dir         (ECalBackend *backend);

Returns the cache directory path used by backend.

backend :

an ECalBackend

Returns :

the cache directory path

Since 2.32


e_cal_backend_dup_cache_dir ()

gchar *             e_cal_backend_dup_cache_dir         (ECalBackend *backend);

Thread-safe variation of e_cal_backend_get_cache_dir(). Use this function when accessing backend from multiple threads.

The returned string should be freed with g_free() when no longer needed.

backend :

an ECalBackend

Returns :

a newly-allocated copy of "cache-dir"

Since 3.10


e_cal_backend_set_cache_dir ()

void                e_cal_backend_set_cache_dir         (ECalBackend *backend,
                                                         const gchar *cache_dir);

Sets the cache directory path for use by backend.

Note that ECalBackend is initialized with a default cache directory path which should suffice for most cases. Backends should not override the default path without good reason.

backend :

an ECalBackend

cache_dir :

a local cache directory path

Since 2.32


e_cal_backend_create_cache_filename ()

gchar *             e_cal_backend_create_cache_filename (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *filename,
                                                         gint fileindex);

backend :

an ECalBackend

uid :

a component UID

filename :

a filename to use; can be NULL

fileindex :

index of a file; used only when filename is NULL

Returns :

a filename for an attachment in a local cache dir. Free returned pointer with a g_free().

Since 3.4


e_cal_backend_add_view ()

void                e_cal_backend_add_view              (ECalBackend *backend,
                                                         EDataCalView *view);

Adds a view to the list of live views being run by the given backend. Doing so means that any listener on the view will get notified of any change that affect the live view.

backend :

an ECalBackend

view :

An EDataCalView object.

Since 3.2


e_cal_backend_remove_view ()

void                e_cal_backend_remove_view           (ECalBackend *backend,
                                                         EDataCalView *view);

Removes view from the list of live views for the backend.

backend :

an ECalBackend

view :

An EDataCalView object, previously added with ref e_cal_backend_add_view.

Since 3.2


e_cal_backend_list_views ()

GList *             e_cal_backend_list_views            (ECalBackend *backend);

Returns a list of ECalBookView instances added with e_cal_backend_add_view().

The views 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 properly in one step is as follows:

1
g_list_free_full (list, g_object_unref);

backend :

an ECalBackend

Returns :

a list of cal views

Since 3.8


e_cal_backend_get_backend_property ()

gchar *             e_cal_backend_get_backend_property  (ECalBackend *backend,
                                                         const gchar *prop_name);

Obtains the value of the backend property named prop_name. Freed the returned string with g_free() when finished with it.

backend :

an ECalBackend

prop_name :

a backend property name

Returns :

the value for prop_name

Since 3.10


e_cal_backend_open_sync ()

gboolean            e_cal_backend_open_sync             (ECalBackend *backend,
                                                         GCancellable *cancellable,
                                                         GError **error);

"Opens" the backend. Opening a backend is something of an outdated concept, but the operation is hanging around for a little while longer. This usually involves some custom initialization logic, and testing of remote authentication if applicable.

If an error occurs, the function will set error and return FALSE.

backend :

an ECalBackend

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_open ()

void                e_cal_backend_open                  (ECalBackend *backend,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously "opens" the backend. Opening a backend is something of an outdated concept, but the operation is hanging around for a little while longer. This usually involves some custom initialization logic, and testing of remote authentication if applicable.

When the operation is finished, callback will be called. You can then call e_cal_backend_open_finish() to get the result of the operation.

backend :

an ECalBackend

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_open_finish ()

gboolean            e_cal_backend_open_finish           (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_open().

If an error occurred, the function will set error and return FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_refresh_sync ()

gboolean            e_cal_backend_refresh_sync          (ECalBackend *backend,
                                                         GCancellable *cancellable,
                                                         GError **error);

Initiates a refresh for backend, if the backend supports refreshing. The actual refresh operation completes on its own time. This function merely initiates the operation.

If an error occrs while initiating the refresh, the function will set error and return FALSE. If the backend does not support refreshing, the function will set an E_CLIENT_ERROR_NOT_SUPPORTED error and return FALSE.

backend :

an ECalBackend

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_refresh ()

void                e_cal_backend_refresh               (ECalBackend *backend,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously initiates a refresh for backend, if the backend supports refreshing. The actual refresh operation completes on its own time. This function, along with e_cal_backend_refresh_finish(), merely initiates the operation.

Once the refresh is initiated, callback will be called. You can then call e_cal-backend_refresh_finish() to get the result of the initiation.

backend :

an ECalBackend

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_refresh_finish ()

gboolean            e_cal_backend_refresh_finish        (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the refresh initiation started with e_cal_backend_refresh().

If an error occurred while initiating the refresh, the function will set error and return FALSE. If the backend does not support refreshing, the function will set an E_CLIENT_ERROR_NOT_SUPPORTED error and return FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_get_object_sync ()

gchar *             e_cal_backend_get_object_sync       (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         GCancellable *cancellable,
                                                         GError **error);

Obtains an iCalendar string for an object identified by its uid and, optionally, rid.

The returned string should be freed with g_free() when finished with it.

If an error occurs, the function will set error and return NULL.

backend :

an ECalBackend

uid :

a unique ID for an iCalendar object

rid :

a recurrence ID, or NULL

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

an ECalComponent, or NULL

Since 3.10


e_cal_backend_get_object ()

void                e_cal_backend_get_object            (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously obtains an ECalComponent by its uid and, optionally, rid.

When the operation is finished, callback will be called. You can then call e_cal_backend_get_object_finish() to get the result of the operation.

backend :

an ECalBackend

uid :

a unique ID for an iCalendar object

rid :

a recurrence ID, or NULL

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_get_object_finish ()

gchar *             e_cal_backend_get_object_finish     (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_get_object().

The returned string is an iCalendar object describing either single component or a vCalendar object, which includes also detached instances. It should be freed when no longer needed.

If an error occurs, the function will set error and return NULL.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

an ECalComponent, or NULL

Since 3.10


e_cal_backend_get_object_list_sync ()

gboolean            e_cal_backend_get_object_list_sync  (ECalBackend *backend,
                                                         const gchar *query,
                                                         GQueue *out_objects,
                                                         GCancellable *cancellable,
                                                         GError **error);

Obtains a set of iCalendar string instances which satisfy the criteria specified in query, and deposits them in out_objects.

The returned instances should be freed with g_free() when finished with them.

If an error occurs, the function will set error and return FALSE. Note that an empty result set does not necessarily imply an error.

backend :

an ECalBackend

query :

a search query in S-expression format

out_objects :

a GQueue in which to deposit results

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_get_object_list ()

void                e_cal_backend_get_object_list       (ECalBackend *backend,
                                                         const gchar *query,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously obtains a set of iCalendar instances which satisfy the criteria specified in query.

When the operation in finished, callback will be called. You can then call e_cal_backend_get_object_list_finish() to get the result of the operation.

backend :

an ECalBackend

query :

a search query in S-expression format

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_get_object_list_finish ()

gboolean            e_cal_backend_get_object_list_finish
                                                        (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GQueue *out_objects,
                                                         GError **error);

Finishes the operation started with e_cal_backend_get_object_list().

The matching iCalendar instances are deposited in out_objects. The returned instances should be freed with g_free() when finished with them.

If an error occurred, the function will set error and return FALSE. Note that an empty result set does not necessarily imply an error.

backend :

an ECalBackend

result :

a GAsyncResult

out_objects :

a GQueue in which to deposit results

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_get_free_busy_sync ()

gboolean            e_cal_backend_get_free_busy_sync    (ECalBackend *backend,
                                                         time_t start,
                                                         time_t end,
                                                         const gchar * const *users,
                                                         GCancellable *cancellable,
                                                         GError **error);

Obtains a free/busy object for the list of users in the time interval between start and end. The free/busy results are returned through the e_data_cal_report_free_busy_data() function rather than directly through this function.

If an error occurs, the function will set error and return FALSE.

backend :

an ECalBackend

start :

start time

end :

end time

users :

a NULL-terminated array of user strings

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure.

Since 3.10


e_cal_backend_get_free_busy ()

void                e_cal_backend_get_free_busy         (ECalBackend *backend,
                                                         time_t start,
                                                         time_t end,
                                                         const gchar * const *users,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously obtains a free/busy object for the list of users in the time interval between start and end.

When the operation is finished, callback will be called. You can then call e_cal_backend_get_free_busy_finish() to get the result of the operation.

backend :

an ECalBackend

start :

start time

end :

end time

users :

a NULL-terminated array of user strings

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_get_free_busy_finish ()

gboolean            e_cal_backend_get_free_busy_finish  (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_get_free_busy().

The free/busy results are returned through the e_data_cal_report_free_busy_data() function rather than directly through this function.

If an error occurred, the function will set error and return FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_create_objects_sync ()

gboolean            e_cal_backend_create_objects_sync   (ECalBackend *backend,
                                                         const gchar * const *calobjs,
                                                         GQueue *out_uids,
                                                         GCancellable *cancellable,
                                                         GError **error);

Creates one or more new iCalendar objects from calobjs, and deposits the unique ID string for each newly-created object in out_uids.

Free the returned ID strings with g_free() when finished with them.

If an error occurs, the function will set error and return FALSE.

backend :

an ECalBackend

calobjs :

a NULL-terminated array of iCalendar strings

out_uids :

a GQueue in which to deposit results

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_create_objects ()

void                e_cal_backend_create_objects        (ECalBackend *backend,
                                                         const gchar * const *calobjs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously creates one or more new iCalendar objects from calobjs.

When the operation is finished, callback will be called. You can then call e_cal_backend_create_objects_finish() to get the result of the operation.

backend :

an ECalBackend

calobjs :

a NULL-terminated array of iCalendar strings

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisifed

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_create_objects_finish ()

gboolean            e_cal_backend_create_objects_finish (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GQueue *out_uids,
                                                         GError **error);

Finishes the operation started with e_cal_backend_create_objects().

A unique ID string for each newly-created object is deposited in out_uids. Free the returned ID strings with g_free() when finished with them.

If an error occurred, the function will set error and return FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

out_uids :

a GQueue in which to deposit results

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_modify_objects_sync ()

gboolean            e_cal_backend_modify_objects_sync   (ECalBackend *backend,
                                                         const gchar * const *calobjs,
                                                         ECalObjModType mod,
                                                         GCancellable *cancellable,
                                                         GError **error);

e_cal_backend_modify_objects ()

void                e_cal_backend_modify_objects        (ECalBackend *backend,
                                                         const gchar * const *calobjs,
                                                         ECalObjModType mod,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously modifies one or more iCalendar objects according to calobjs and mod.

When the operation is finished, callback will be called. You can then call e_cal_backend_modify_objects_finish() to get the result of the operation.

backend :

an ECalBackend

calobjs :

a NULL-terminated array of iCalendar strings

mod :

modification type for recurrences

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_modify_objects_finish ()

gboolean            e_cal_backend_modify_objects_finish (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_modify_objects().

If an error occurred, the function will set error and return FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_remove_objects_sync ()

gboolean            e_cal_backend_remove_objects_sync   (ECalBackend *backend,
                                                         GList *component_ids,
                                                         ECalObjModType mod,
                                                         GCancellable *cancellable,
                                                         GError **error);

Removes one or more iCalendar objects according to component_ids and mod.

If an error occurs, the function will set error and return FALSE.

backend :

an ECalBackend

component_ids :

a GList of ECalComponentId structs

mod :

modification type for recurrences

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_remove_objects ()

void                e_cal_backend_remove_objects        (ECalBackend *backend,
                                                         GList *component_ids,
                                                         ECalObjModType mod,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously removes one or more iCalendar objects according to component_ids and mod.

When the operation is finished, callback will be called. You can then call e_cal_backend_remove_objects_finish() to get the result of the operation.

backend :

an ECalBackend

component_ids :

a GList of ECalComponentId structs

mod :

modification type for recurrences

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_remove_objects_finish ()

gboolean            e_cal_backend_remove_objects_finish (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_remove_objects().

If an error occurred, the function will set error and return FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_receive_objects_sync ()

gboolean            e_cal_backend_receive_objects_sync  (ECalBackend *backend,
                                                         const gchar *calobj,
                                                         GCancellable *cancellable,
                                                         GError **error);

Receives the set of iCalendar objects specified by calobj. This is used for iTIP confirmation and cancellation messages for scheduled meetings.

If an error occurs, the function will set error and return FALSE.

backend :

an ECalBackend

calobj :

an iCalendar string

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_receive_objects ()

void                e_cal_backend_receive_objects       (ECalBackend *backend,
                                                         const gchar *calobj,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously receives the set of iCalendar objects specified by calobj. This is used for iTIP confirmation and cancellation messages for scheduled meetings.

When the operation is finished, callback will be called. You can then call e_cal_backend_receive_objects_finish() to get the result of the operation.

backend :

an ECalBackend

calobj :

an iCalendar string

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_receive_objects_finish ()

gboolean            e_cal_backend_receive_objects_finish
                                                        (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_receive_objects().

If an error occurred, the function will set error and erturn FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_send_objects_sync ()

gchar *             e_cal_backend_send_objects_sync     (ECalBackend *backend,
                                                         const gchar *calobj,
                                                         GQueue *out_users,
                                                         GCancellable *cancellable,
                                                         GError **error);

Sends meeting information in calobj. The backend may modify calobj and send meeting information only to particular users. The function returns the (maybe) modified calobj and deposits the list of users the meeting information was sent (to be send) to in out_users.

The returned pointer should be freed with g_free(), when no londer needed.

If an error occurs, the function will set error and return NULL.

backend :

an ECalBackend

calobj :

an iCalendar string

out_users :

a GQueue in which to deposit results

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

a vCalendar string, or NULL

Since 3.10


e_cal_backend_send_objects ()

void                e_cal_backend_send_objects          (ECalBackend *backend,
                                                         const gchar *calobj,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously sends meeting information in calobj. The backend may modify calobj and send meeting information only to particular users.

When the operation is finished, callback will be called. You can then call e_cal_backend_send_objects_finish() to get the result of the operation.

backend :

an ECalBackend

calobj :

an iCalendar string

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_send_objects_finish ()

gchar *             e_cal_backend_send_objects_finish   (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GQueue *out_users,
                                                         GError **error);

Finishes the operation started with e_cal_backend_send_objects().

The function returns a string representation of a sent, or to be send, vCalendar and deposits the list of users the meeting information was sent to, or to be send to, in out_users.

Free the returned pointer with g_free(), when no longer needed.

If an error occurs, the function will set error and return NULL.

backend :

an ECalBackend

result :

a GAsyncResult

out_users :

a GQueue in which to deposit results

error :

return location for a GError, or NULL

Returns :

a newly allocated vCalendar string, or NULL

Since 3.10


e_cal_backend_get_attachment_uris_sync ()

gboolean            e_cal_backend_get_attachment_uris_sync
                                                        (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         GQueue *out_attachment_uris,
                                                         GCancellable *cancellable,
                                                         GError **error);

Inspects the iCalendar object specified by uid and, optionally, rid for attachments and deposits a URI string for each attachment in out_attachment_uris. Free the returned strings with g_free() when finished with them.

If an error occurs, the function will set error and return FALSE. Note that an empty result set does not necessarily imply an error.

backend :

an ECalBackend

uid :

a unique ID for an iCalendar object

rid :

a recurrence ID, or NULL

out_attachment_uris :

a GQueue in which to deposit results

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_get_attachment_uris ()

void                e_cal_backend_get_attachment_uris   (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously inspects the iCalendar object specified by uid and, optionally, rid for attachments.

When the operation is finished, callback will be called. You can then call e_cal_backend_get_attachment_uris_finish() to get the result of the operation.

backend :

an ECalBackend

uid :

a unique ID for an iCalendar object

rid :

a recurrence ID, or NULL

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_get_attachment_uris_finish ()

gboolean            e_cal_backend_get_attachment_uris_finish
                                                        (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GQueue *out_attachment_uris,
                                                         GError **error);

Finishes the operation started with e_cal_backend_get_attachment_uris().

The requested attachment URI strings are deposited in out_attachment_uris. Free the returned strings with g_free() when finished with them.

If an error occurred, the function will set error and return FALSE. Note that an empty result set does not necessarily imply an error.

backend :

an ECalBackend

result :

a GAsyncResult

out_attachment_uris :

a GQueue in which to deposit results

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_discard_alarm_sync ()

gboolean            e_cal_backend_discard_alarm_sync    (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         const gchar *alarm_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);

Discards the VALARM object with a unique ID of alarm_uid from the iCalendar object identified by uid and, optionally, rid.

If an error occurs, the function will set error and return FALSE.

backend :

an ECalBackend

uid :

a unique ID for an iCalendar object

rid :

a recurrence ID, or NULL

alarm_uid :

a unique ID for an iCalendar VALARM object

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_discard_alarm ()

void                e_cal_backend_discard_alarm         (ECalBackend *backend,
                                                         const gchar *uid,
                                                         const gchar *rid,
                                                         const gchar *alarm_uid,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously discards the VALARM object with a unique ID of alarm_uid from the iCalendar object identified by uid and, optionally, rid.

When the operation is finished, callback will be called. You can then call e_cal_backend_discard_alarm_finish() to get the result of the operation.

backend :

an ECalBackend

uid :

a unique ID for an iCalendar object

rid :

a recurrence ID, or NULL

alarm_uid :

a unique ID for an iCalendar VALARM object

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_discard_alarm_finish ()

gboolean            e_cal_backend_discard_alarm_finish  (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_discard_alarm().

If an error occurred, the function will set error and return FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_get_timezone_sync ()

gchar *             e_cal_backend_get_timezone_sync     (ECalBackend *backend,
                                                         const gchar *tzid,
                                                         GCancellable *cancellable,
                                                         GError **error);

Obtains the VTIMEZONE object identified by tzid. Free the returned string with g_free() when finished with it.

If an error occurs, the function will set error and return NULL.

backend :

an ECalBackend

tzid :

a unique ID for an iCalendar VTIMEZONE object

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

an iCalendar string, or NULL

Since 3.10


e_cal_backend_get_timezone ()

void                e_cal_backend_get_timezone          (ECalBackend *backend,
                                                         const gchar *tzid,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously obtains the VTIMEZONE object identified by tzid.

When the operation is finished, callback will be called. You can then call e_cal_backend_get_timezone_finish() to get the result of the operation.

backend :

an ECalBackend

tzid :

a unique ID for an iCalendar VTIMEZONE object

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_get_timezone_finish ()

gchar *             e_cal_backend_get_timezone_finish   (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_get_timezone().

Free the returned string with g_free() when finished with it.

If an error occurred, the function will set error and return NULL.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

an iCalendar string, or NULL

Since 3.10


e_cal_backend_add_timezone_sync ()

gboolean            e_cal_backend_add_timezone_sync     (ECalBackend *backend,
                                                         const gchar *tzobject,
                                                         GCancellable *cancellable,
                                                         GError **error);

Adds the timezone described by tzobject to backend.

If an error occurs, the function will set error and return FALSE.

backend :

an ECalBackend

tzobject :

an iCalendar VTIMEZONE string

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_add_timezone ()

void                e_cal_backend_add_timezone          (ECalBackend *backend,
                                                         const gchar *tzobject,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously adds the timezone described by tzobject to backend.

When the operation is finished, callback will be called. You can then call e_cal_backend_add_timezone_finish() to get the result of the operation.

backend :

an ECalBackend

tzobject :

an iCalendar VTIMEZONE string

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.10


e_cal_backend_add_timezone_finish ()

gboolean            e_cal_backend_add_timezone_finish   (ECalBackend *backend,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with e_cal_backend_add_timezone().

If an error occurred, the function will set error and return FALSE.

backend :

an ECalBackend

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.10


e_cal_backend_start_view ()

void                e_cal_backend_start_view            (ECalBackend *backend,
                                                         EDataCalView *view);

Starts a new live view on the given backend.

backend :

an ECalBackend

view :

The view to be started.

Since 3.2


e_cal_backend_stop_view ()

void                e_cal_backend_stop_view             (ECalBackend *backend,
                                                         EDataCalView *view);

Stops a previously started live view on the given backend.

backend :

an ECalBackend

view :

The view to be stopped.

Since 3.2


e_cal_backend_notify_component_created ()

void                e_cal_backend_notify_component_created
                                                        (ECalBackend *backend,
                                                         ECalComponent *component);

Notifies each of the backend's listeners about a new object.

Like e_cal_backend_notify_object_created() except takes an ECalComponent instead of an ical string representation and uses the EDataCalView's fields-of-interest to filter out unwanted information from ical strings sent over the bus.

backend :

an ECalBackend

component :

the newly created ECalComponent

Since 3.4


e_cal_backend_notify_component_modified ()

void                e_cal_backend_notify_component_modified
                                                        (ECalBackend *backend,
                                                         ECalComponent *old_component,
                                                         ECalComponent *new_component);

Notifies each of the backend's listeners about a modified object.

Like e_cal_backend_notify_object_modified() except takes an ECalComponent instead of an ical string representation and uses the EDataCalView's fields-of-interest to filter out unwanted information from ical strings sent over the bus.

backend :

an ECalBackend

old_component :

the ECalComponent before the modification

new_component :

the ECalComponent after the modification

Since 3.4


e_cal_backend_notify_component_removed ()

void                e_cal_backend_notify_component_removed
                                                        (ECalBackend *backend,
                                                         const ECalComponentId *id,
                                                         ECalComponent *old_component,
                                                         ECalComponent *new_component);

Notifies each of the backend's listeners about a removed object.

Like e_cal_backend_notify_object_removed() except takes an ECalComponent instead of an ical string representation and uses the EDataCalView's fields-of-interest to filter out unwanted information from ical strings sent over the bus.

backend :

an ECalBackend

id :

the Id of the removed object

old_component :

the removed component

new_component :

the component after the removal. This only applies to recurrent appointments that had an instance removed. In that case, this function notifies a modification instead of a removal.

Since 3.4


e_cal_backend_notify_error ()

void                e_cal_backend_notify_error          (ECalBackend *backend,
                                                         const gchar *message);

Notifies each of the backend's listeners about an error

backend :

an ECalBackend

message :

Error message

e_cal_backend_notify_property_changed ()

void                e_cal_backend_notify_property_changed
                                                        (ECalBackend *backend,
                                                         const gchar *prop_name,
                                                         const gchar *prop_value);

Notifies client about property value change.

backend :

an ECalBackend

prop_name :

property name, which changed

prop_value :

new property value

Since 3.2


e_cal_backend_empty_cache ()

void                e_cal_backend_empty_cache           (ECalBackend *backend,
                                                         struct _ECalBackendCache *cache);

Empties backend's cache with all notifications and so on, thus all listening will know there is nothing in this backend.

backend :

an ECalBackend

cache :

Backend's cache to empty.

Since 2.28

Property Details

The "cache-dir" property

  "cache-dir"                gchar*                : Read / Write

The backend's cache directory.

Default value: NULL


The "kind" property

  "kind"                     gulong                : Read / Write / Construct Only

The kind of iCalendar components this backend manages.

Allowed values: <= 25


The "registry" property

  "registry"                 ESourceRegistry*      : Read / Write / Construct Only

Data source registry.


The "writable" property

  "writable"                 gboolean              : Read / Write

Whether the backend will accept changes.

Default value: FALSE

Signal Details

The "closed" signal

void                user_function                      (ECalBackend *backend,
                                                        gchar       *sender,
                                                        gpointer     user_data)      : Run Last

Emitted when a client destroys its ECalClient for backend

backend :

the ECalBackend which emitted the signal

sender :

the bus name that invoked the "close" method

user_data :

user data set when the signal handler was connected.

Since 3.10


The "shutdown" signal

void                user_function                      (ECalBackend *backend,
                                                        gpointer     user_data)      : Run Last

Emitted when the last client destroys its ECalClient for backend. This signals the backend to begin final cleanup tasks such as synchronizing data to permanent storage.

backend :

the ECalBackend which emitted the signal

user_data :

user data set when the signal handler was connected.

Since 3.10