MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_READONLY

#define MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_READONLY -1

MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_DEFAULT

#define MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_DEFAULT   0

MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_NORMAL

#define MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_NORMAL    100

MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_KEYRING

#define MCP_ACCOUNT_STORAGE_PLUGIN_PRIO_KEYRING   10000

McpAccountStorage

typedef struct _McpAccountStorage McpAccountStorage;

McpAccountStorageIface

typedef struct _McpAccountStorageIface McpAccountStorageIface;

mcp_account_storage_iface_set_priority ()

void                mcp_account_storage_iface_set_priority
                                                        (McpAccountStorageIface *iface,
                                                         guint prio);

mcp_account_storage_iface_set_name ()

void                mcp_account_storage_iface_set_name  (McpAccountStorageIface *iface,
                                                         const gchar *name);

mcp_account_storage_iface_set_desc ()

void                mcp_account_storage_iface_set_desc  (McpAccountStorageIface *iface,
                                                         const gchar *desc);

mcp_account_storage_iface_set_provider ()

void                mcp_account_storage_iface_set_provider
                                                        (McpAccountStorageIface *iface,
                                                         const gchar *provider);

mcp_account_storage_iface_implement_get ()

void                mcp_account_storage_iface_implement_get
                                                        (McpAccountStorageIface *iface,
                                                         gboolean (method const McpAccountStorage *, const McpAccountManager *, const gchar *, const gchar *) ());

mcp_account_storage_iface_implement_set ()

void                mcp_account_storage_iface_implement_set
                                                        (McpAccountStorageIface *iface,
                                                         gboolean (method const McpAccountStorage *, const McpAccountManager *, const gchar *, const gchar *, const gchar *) ());

mcp_account_storage_iface_implement_delete ()

void                mcp_account_storage_iface_implement_delete
                                                        (McpAccountStorageIface *iface,
                                                         gboolean (method const McpAccountStorage *, const McpAccountManager *, const gchar *, const gchar *) ());

mcp_account_storage_iface_implement_list ()

void                mcp_account_storage_iface_implement_list
                                                        (McpAccountStorageIface *iface,
                                                         GList* (method const McpAccountStorage *, const McpAccountManager *) ());

mcp_account_storage_iface_implement_commit ()

void                mcp_account_storage_iface_implement_commit
                                                        (McpAccountStorageIface *iface,
                                                         gboolean (method const McpAccountStorage *, const McpAccountManager *) ());

mcp_account_storage_iface_implement_commit_one ()

void                mcp_account_storage_iface_implement_commit_one
                                                        (McpAccountStorageIface *iface,
                                                         gboolean (method const McpAccountStorage *, const McpAccountManager *, const gchar *) ());

mcp_account_storage_iface_implement_ready ()

void                mcp_account_storage_iface_implement_ready
                                                        (McpAccountStorageIface *iface,
                                                         void (method const McpAccountStorage *storage, const McpAccountManager *am) ());

mcp_account_storage_iface_implement_get_identifier ()

void                mcp_account_storage_iface_implement_get_identifier
                                                        (McpAccountStorageIface *iface,
                                                         void (method const McpAccountStorage *, const gchar *, GValue *) ());

mcp_account_storage_iface_implement_get_additional_info ()

void                mcp_account_storage_iface_implement_get_additional_info
                                                        (McpAccountStorageIface *iface,
                                                         GHashTable* (method const McpAccountStorage *, const gchar *) ());

mcp_account_storage_iface_implement_get_restrictions ()

void                mcp_account_storage_iface_implement_get_restrictions
                                                        (McpAccountStorageIface *iface,
                                                         guint (method const McpAccountStorage *, const gchar *) ());

mcp_account_storage_priority ()

gint                mcp_account_storage_priority        (const McpAccountStorage *storage);

mcp_account_storage_get ()

gboolean            mcp_account_storage_get             (const McpAccountStorage *storage,
                                                         McpAccountManager *am,
                                                         const gchar *account,
                                                         const gchar *key);

The plugin is expected to quickly and synchronously update the value associated with key using calls to am.

The plugin is not required to consult whatever long term storage it uses, and may fetch said value from its internal cache, if any.

If key is NULL the plugin should write all its settings for account into the account manager via am. The return value in this case should be TRUE if any settings were found.

mcp_account_storage_set ()

gboolean            mcp_account_storage_set             (const McpAccountStorage *storage,
                                                         const McpAccountManager *am,
                                                         const gchar *account,
                                                         const gchar *key,
                                                         const gchar *val);

The plugin is expected to either quickly and synchronously update its internal cache of values with value, or to decline to store the setting.

The plugin is not expected to write to its long term storage at this point.

mcp_account_storage_delete ()

gboolean            mcp_account_storage_delete          (const McpAccountStorage *storage,
                                                         const McpAccountManager *am,
                                                         const gchar *account,
                                                         const gchar *key);

The plugin is expected to remove the setting for key from its internal cache and to remember that its state has changed, so that it can delete said setting from its long term storage if its long term storage method makes this necessary.

If key is NULL, the plugin should forget all its settings for account (and remember to delete account from its storage later)

The plugin is not expected to update its long term storage at this point.

mcp_account_storage_ready ()

void                mcp_account_storage_ready           (const McpAccountStorage *storage,
                                                         const McpAccountManager *am);

Informs the plugin that it is now permitted to create new accounts, ie it can now fire its "created", "altered", "toggled" and "deleted" signals.

mcp_account_storage_commit ()

gboolean            mcp_account_storage_commit          (const McpAccountStorage *storage,
                                                         const McpAccountManager *am);

The plugin is expected to write its cache to long term storage, deleting, adding or updating entries in said storage as needed.

This call is expected to return promptly, but the plugin is not required to have finished its commit operation when it returns, merely to have started the operation.

If the commit_one method is implemented, it will be called preferentially if only one account is to be committed. If the commit_one method is implemented but commit is not, commit_one will be called with account_name = NULL to commit all accounts.

mcp_account_storage_commit_one ()

gboolean            mcp_account_storage_commit_one      (const McpAccountStorage *storage,
                                                         const McpAccountManager *am,
                                                         const gchar *account);

The same as mcp_account_storage_commit(), but only commit the given account. This is optional to implement; the default implementation is to call commit.

mcp_account_storage_list ()

GList *             mcp_account_storage_list            (const McpAccountStorage *storage,
                                                         const McpAccountManager *am);

This method is called only at initialisation time, before the dbus name has been claimed, and is the only one permitted to block.

mcp_account_storage_get_identifier ()

void                mcp_account_storage_get_identifier  (const McpAccountStorage *storage,
                                                         const gchar *account,
                                                         GValue *identifier);

Get the storage-specific identifier for this account. The type is variant, hence the GValue.

mcp_account_storage_get_additional_info ()

GHashTable *        mcp_account_storage_get_additional_info
                                                        (const McpAccountStorage *storage,
                                                         const gchar *account);

Return additional storage-specific information about this account, which is made available on D-Bus but not otherwise interpreted by Mission Control.

mcp_account_storage_get_restrictions ()

guint               mcp_account_storage_get_restrictions
                                                        (const McpAccountStorage *storage,
                                                         const gchar *account);

mcp_account_storage_name ()

const gchar *       mcp_account_storage_name            (const McpAccountStorage *storage);

mcp_account_storage_description ()

const gchar *       mcp_account_storage_description     (const McpAccountStorage *storage);

mcp_account_storage_provider ()

const gchar *       mcp_account_storage_provider        (const McpAccountStorage *storage);

The "altered" signal

void                user_function                      (McpAccountStorage *account,
                                                        gchar             *arg1,
                                                        gpointer           user_data)      : Run Last

emitted if an external entity alters an account in the backend the emitting plugin handles should not be emitted if a single known property has been altered, see McpAccountStorage::altered-one instead

Should not be fired until mcp_account_storage_ready() has been called

The "altered-one" signal

void                user_function                      (McpAccountStorage *account,
                                                        gchar             *name,
                                                        gchar             *arg2,
                                                        gpointer           user_data)      : Run Last

emitted if an external entity alters an account in the backend that the emitting plugin handles.

If many properties have changed, the plugin may choose to emit McpAccountStorage::altered _instead_, but should not emit both.

Should not be fired until mcp_account_storage_ready() has been called

The "created" signal

void                user_function                      (McpAccountStorage *account,
                                                        gchar             *arg1,
                                                        gpointer           user_data)      : Run Last

emitted if an external entity creates an account in the backend the emitting plugin handles

Should not be fired until mcp_account_storage_ready() has been called

The "deleted" signal

void                user_function                      (McpAccountStorage *account,
                                                        gchar             *arg1,
                                                        gpointer           user_data)      : Run Last

emitted if an external entity deletes an account in the backend the emitting plugin handles

Should not be fired until mcp_account_storage_ready() has been called

The "toggled" signal

void                user_function                      (McpAccountStorage *account,
                                                        gchar             *enabled,
                                                        gboolean           arg2,
                                                        gpointer           user_data)      : Run Last

emitted if an external entity enables/disables an account in the backend the emitting plugin handles

Should not be fired until mcp_account_storage_ready() has been called