854 lines
28 KiB
C
854 lines
28 KiB
C
/*
|
|
* Copyright (C) 2009 Intel Corporation
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) version 3.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301 USA
|
|
*/
|
|
|
|
#include <glib-object.h>
|
|
#include <string.h>
|
|
|
|
#include "syncevo-server.h"
|
|
#include "syncevo-marshal.h"
|
|
#include "syncevo-server-bindings.h"
|
|
|
|
typedef struct _ServerAsyncData {
|
|
SyncevoServer *server;
|
|
GCallback callback;
|
|
gpointer userdata;
|
|
} ServerAsyncData;
|
|
|
|
enum {
|
|
SESSION_CHANGED,
|
|
PRESENCE_CHANGED,
|
|
INFO_REQUEST,
|
|
TEMPLATES_CHANGED,
|
|
SHUTDOWN,
|
|
LAST_SIGNAL
|
|
};
|
|
static guint32 signals[LAST_SIGNAL] = {0, };
|
|
|
|
typedef struct _SyncevoServerPrivate {
|
|
DBusGProxy *proxy;
|
|
} SyncevoServerPrivate;
|
|
|
|
#define GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SYNCEVO_TYPE_SERVER, SyncevoServerPrivate))
|
|
G_DEFINE_TYPE (SyncevoServer, syncevo_server, G_TYPE_OBJECT);
|
|
|
|
static ServerAsyncData*
|
|
server_async_data_new (SyncevoServer *server,
|
|
GCallback callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
|
|
data = g_slice_new0 (ServerAsyncData);
|
|
data->server = server;
|
|
data->callback = G_CALLBACK (callback);
|
|
data->userdata = userdata;
|
|
|
|
return data;
|
|
}
|
|
|
|
static void
|
|
server_async_data_free (ServerAsyncData *data)
|
|
{
|
|
g_slice_free (ServerAsyncData, data);
|
|
}
|
|
|
|
static void
|
|
generic_callback (DBusGProxy *proxy,
|
|
GError *error,
|
|
ServerAsyncData *data)
|
|
{
|
|
if (data->callback) {
|
|
(*(SyncevoServerGenericCb)data->callback) (data->server,
|
|
error,
|
|
data->userdata);
|
|
}
|
|
server_async_data_free (data);
|
|
}
|
|
|
|
static gboolean
|
|
generic_error (ServerAsyncData *data)
|
|
{
|
|
GError *error;
|
|
|
|
error = g_error_new_literal (SYNCEVO_SERVER_ERROR_QUARK,
|
|
SYNCEVO_SERVER_ERROR_NO_DBUS_OBJECT,
|
|
"The D-Bus object does not exist");
|
|
(*(SyncevoServerGenericCb)data->callback) (data->server,
|
|
error,
|
|
data->userdata);
|
|
server_async_data_free (data);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
templates_changed_cb (DBusGProxy *proxy,
|
|
SyncevoServer *server)
|
|
{
|
|
g_signal_emit (server, signals[TEMPLATES_CHANGED], 0);
|
|
}
|
|
|
|
static void
|
|
session_changed_cb (DBusGProxy *proxy,
|
|
char *session_path,
|
|
gboolean started,
|
|
SyncevoServer *server)
|
|
{
|
|
g_signal_emit (server, signals[SESSION_CHANGED], 0,
|
|
session_path, started);
|
|
}
|
|
|
|
static void
|
|
presence_cb (DBusGProxy *proxy,
|
|
char *configuration,
|
|
char *status,
|
|
char *transport,
|
|
SyncevoServer *server)
|
|
{
|
|
g_signal_emit (server, signals[PRESENCE_CHANGED], 0,
|
|
configuration, status, transport);
|
|
}
|
|
|
|
static void
|
|
info_request_cb (DBusGProxy *proxy,
|
|
char *id,
|
|
char *session_path,
|
|
char *state,
|
|
char *handler_path,
|
|
char *type,
|
|
GHashTable *parameters,
|
|
SyncevoServer *server)
|
|
{
|
|
g_signal_emit (server, signals[INFO_REQUEST], 0,
|
|
id, session_path, state, handler_path, type, parameters);
|
|
}
|
|
|
|
static void
|
|
proxy_destroy_cb (DBusGProxy *proxy,
|
|
SyncevoServer *server)
|
|
{
|
|
SyncevoServerPrivate *priv;
|
|
priv = GET_PRIVATE (server);
|
|
|
|
if (priv->proxy) {
|
|
g_object_unref (priv->proxy);
|
|
}
|
|
priv->proxy = NULL;
|
|
|
|
g_signal_emit (server, signals[SHUTDOWN], 0);
|
|
}
|
|
|
|
#if 0
|
|
static void
|
|
detach_cb (DBusGProxy *proxy,
|
|
GError *error,
|
|
gpointer userdata)
|
|
{
|
|
if (error) {
|
|
g_warning ("Server.Detach failed: %s", error->message);
|
|
g_error_free (error);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
dispose (GObject *object)
|
|
{
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (object);
|
|
|
|
if (priv->proxy) {
|
|
dbus_g_proxy_disconnect_signal (priv->proxy, "SessionChanged",
|
|
G_CALLBACK (session_changed_cb),
|
|
object);
|
|
dbus_g_proxy_disconnect_signal (priv->proxy, "Presence",
|
|
G_CALLBACK (presence_cb),
|
|
object);
|
|
dbus_g_proxy_disconnect_signal (priv->proxy, "InfoRequest",
|
|
G_CALLBACK (info_request_cb),
|
|
object);
|
|
dbus_g_proxy_disconnect_signal (priv->proxy, "TemplatesChanged",
|
|
G_CALLBACK (templates_changed_cb),
|
|
object);
|
|
dbus_g_proxy_disconnect_signal (priv->proxy, "destroy",
|
|
G_CALLBACK (proxy_destroy_cb),
|
|
object);
|
|
org_syncevolution_Server_detach (priv->proxy, NULL);
|
|
|
|
g_object_unref (priv->proxy);
|
|
priv->proxy = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (syncevo_server_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
attach_cb (DBusGProxy *proxy,
|
|
GError *error,
|
|
gpointer userdata)
|
|
{
|
|
if (error) {
|
|
g_warning ("Server.Attach failed: %s", error->message);
|
|
g_error_free (error);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
syncevo_server_get_new_proxy (SyncevoServer *server)
|
|
{
|
|
DBusGConnection *connection;
|
|
GError *error;
|
|
guint32 result;
|
|
SyncevoServerPrivate *priv;
|
|
DBusGProxy *proxy;
|
|
|
|
priv = GET_PRIVATE (server);
|
|
error = NULL;
|
|
|
|
connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
|
|
if (connection == NULL) {
|
|
g_printerr ("Failed to open connection to bus: %s\n",
|
|
error->message);
|
|
g_error_free (error);
|
|
priv->proxy = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
/* we want to use dbus_g_proxy_new_for_name_owner() for the destroy signal
|
|
* so need to start the service by hand by using DBUS proxy: */
|
|
proxy = dbus_g_proxy_new_for_name (connection,
|
|
DBUS_SERVICE_DBUS,
|
|
DBUS_PATH_DBUS,
|
|
DBUS_INTERFACE_DBUS);
|
|
if (!dbus_g_proxy_call (proxy, "StartServiceByName", NULL,
|
|
G_TYPE_STRING, DBUS_SERVICE_SYNCEVO_SERVER,
|
|
G_TYPE_UINT, 0,
|
|
G_TYPE_INVALID,
|
|
G_TYPE_UINT, &result,
|
|
G_TYPE_INVALID)) {
|
|
g_warning ("StartServiceByName call failed");
|
|
}
|
|
g_object_unref (proxy);
|
|
|
|
/* the real proxy */
|
|
priv->proxy = dbus_g_proxy_new_for_name_owner (connection,
|
|
DBUS_SERVICE_SYNCEVO_SERVER,
|
|
DBUS_PATH_SYNCEVO_SERVER,
|
|
DBUS_INTERFACE_SYNCEVO_SERVER,
|
|
&error);
|
|
if (priv->proxy == NULL) {
|
|
g_printerr ("dbus_g_proxy_new_for_name_owner() failed: %s\n", error->message);
|
|
g_error_free (error);
|
|
return FALSE;
|
|
}
|
|
|
|
dbus_g_proxy_add_signal (priv->proxy, "SessionChanged",
|
|
DBUS_TYPE_G_OBJECT_PATH, G_TYPE_BOOLEAN, G_TYPE_INVALID);
|
|
dbus_g_proxy_connect_signal (priv->proxy, "SessionChanged",
|
|
G_CALLBACK (session_changed_cb), server, NULL);
|
|
dbus_g_proxy_add_signal (priv->proxy, "Presence",
|
|
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
|
|
dbus_g_proxy_connect_signal (priv->proxy, "Presence",
|
|
G_CALLBACK (presence_cb), server, NULL);
|
|
dbus_g_proxy_add_signal (priv->proxy, "InfoRequest",
|
|
G_TYPE_STRING,
|
|
DBUS_TYPE_G_OBJECT_PATH,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
SYNCEVO_TYPE_STRING_STRING_HASHTABLE,
|
|
G_TYPE_INVALID);
|
|
dbus_g_proxy_connect_signal (priv->proxy, "InfoRequest",
|
|
G_CALLBACK (info_request_cb), server, NULL);
|
|
dbus_g_proxy_add_signal (priv->proxy, "TemplatesChanged", G_TYPE_INVALID);
|
|
dbus_g_proxy_connect_signal (priv->proxy, "TemplatesChanged",
|
|
G_CALLBACK (templates_changed_cb), server, NULL);
|
|
g_signal_connect (priv->proxy, "destroy",
|
|
G_CALLBACK (proxy_destroy_cb), server);
|
|
|
|
org_syncevolution_Server_attach_async (priv->proxy,
|
|
(org_syncevolution_Server_attach_reply)attach_cb,
|
|
NULL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void
|
|
syncevo_server_init (SyncevoServer *server)
|
|
{
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (server);
|
|
|
|
/* SessionChanged */
|
|
dbus_g_object_register_marshaller (syncevo_marshal_VOID__STRING_BOOLEAN,
|
|
G_TYPE_NONE,
|
|
DBUS_TYPE_G_OBJECT_PATH,
|
|
G_TYPE_BOOLEAN,
|
|
G_TYPE_INVALID);
|
|
/* Presence */
|
|
dbus_g_object_register_marshaller (syncevo_marshal_VOID__STRING_STRING_STRING,
|
|
G_TYPE_NONE,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_INVALID);
|
|
/* InfoRequest */
|
|
dbus_g_object_register_marshaller (syncevo_marshal_VOID__STRING_STRING_STRING_STRING_STRING_BOXED,
|
|
G_TYPE_NONE,
|
|
G_TYPE_STRING,
|
|
DBUS_TYPE_G_OBJECT_PATH,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_BOXED,
|
|
G_TYPE_INVALID);
|
|
|
|
/* TemplatesChanged */
|
|
dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__VOID,
|
|
G_TYPE_NONE,
|
|
G_TYPE_INVALID);
|
|
|
|
syncevo_server_get_new_proxy (server);
|
|
}
|
|
|
|
static void
|
|
syncevo_server_class_init (SyncevoServerClass *klass)
|
|
{
|
|
GObjectClass *o_class = (GObjectClass *) klass;
|
|
|
|
o_class->dispose = dispose;
|
|
|
|
g_type_class_add_private (klass, sizeof (SyncevoServerPrivate));
|
|
|
|
signals[SESSION_CHANGED] =
|
|
g_signal_new ("session-changed",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
|
|
G_STRUCT_OFFSET (SyncevoServerClass, session_changed),
|
|
NULL, NULL,
|
|
syncevo_marshal_VOID__STRING_BOOLEAN,
|
|
G_TYPE_NONE,
|
|
2, G_TYPE_STRING, G_TYPE_BOOLEAN);
|
|
signals[PRESENCE_CHANGED] =
|
|
g_signal_new ("presence-changed",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
|
|
G_STRUCT_OFFSET (SyncevoServerClass, presence_changed),
|
|
NULL, NULL,
|
|
syncevo_marshal_VOID__STRING_STRING_STRING,
|
|
G_TYPE_NONE,
|
|
3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
|
|
signals[INFO_REQUEST] =
|
|
g_signal_new ("info-request",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
|
|
G_STRUCT_OFFSET (SyncevoServerClass, info_request),
|
|
NULL, NULL,
|
|
syncevo_marshal_VOID__STRING_STRING_STRING_STRING_STRING_BOXED,
|
|
G_TYPE_NONE,
|
|
6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
|
|
signals[TEMPLATES_CHANGED] =
|
|
g_signal_new ("templates-changed",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
|
|
G_STRUCT_OFFSET (SyncevoServerClass, templates_changed),
|
|
NULL, NULL,
|
|
g_cclosure_marshal_VOID__VOID,
|
|
G_TYPE_NONE,
|
|
0);
|
|
signals[SHUTDOWN] =
|
|
g_signal_new ("shutdown",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
|
|
G_STRUCT_OFFSET (SyncevoServerClass, shutdown),
|
|
NULL, NULL,
|
|
g_cclosure_marshal_VOID__VOID,
|
|
G_TYPE_NONE,
|
|
0);
|
|
}
|
|
|
|
SyncevoServer *
|
|
syncevo_server_get_default ()
|
|
{
|
|
static SyncevoServer *server = NULL;
|
|
|
|
if (server == NULL) {
|
|
server = g_object_new (SYNCEVO_TYPE_SERVER, NULL);
|
|
g_object_add_weak_pointer (G_OBJECT (server),
|
|
(gpointer) &server);
|
|
return server;
|
|
}
|
|
|
|
return g_object_ref (server);
|
|
}
|
|
|
|
|
|
static void
|
|
get_configs_callback (DBusGProxy *proxy,
|
|
char **config_names,
|
|
GError *error,
|
|
ServerAsyncData *data)
|
|
{
|
|
if (data->callback) {
|
|
(*(SyncevoServerGetConfigsCb)data->callback) (data->server,
|
|
config_names,
|
|
error,
|
|
data->userdata);
|
|
}
|
|
server_async_data_free (data);
|
|
}
|
|
|
|
static gboolean
|
|
get_configs_error (ServerAsyncData *data)
|
|
{
|
|
GError *error;
|
|
|
|
error = g_error_new_literal (SYNCEVO_SERVER_ERROR_QUARK,
|
|
SYNCEVO_SERVER_ERROR_NO_DBUS_OBJECT,
|
|
"Could not start service");
|
|
(*(SyncevoServerGetConfigsCb)data->callback) (data->server,
|
|
NULL,
|
|
error,
|
|
data->userdata);
|
|
server_async_data_free (data);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
syncevo_server_get_configs (SyncevoServer *syncevo,
|
|
gboolean template,
|
|
SyncevoServerGetConfigsCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (syncevo);
|
|
|
|
data = server_async_data_new (syncevo, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy && !syncevo_server_get_new_proxy (syncevo)) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)get_configs_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_get_configs_async
|
|
(priv->proxy,
|
|
template,
|
|
(org_syncevolution_Server_get_configs_reply) get_configs_callback,
|
|
data);
|
|
}
|
|
|
|
static void
|
|
get_config_callback (DBusGProxy *proxy,
|
|
SyncevoConfig *configuration,
|
|
GError *error,
|
|
ServerAsyncData *data)
|
|
{
|
|
if (data->callback) {
|
|
(*(SyncevoServerGetConfigCb)data->callback) (data->server,
|
|
configuration,
|
|
error,
|
|
data->userdata);
|
|
}
|
|
server_async_data_free (data);
|
|
}
|
|
|
|
static gboolean
|
|
get_config_error (ServerAsyncData *data)
|
|
{
|
|
GError *error;
|
|
|
|
error = g_error_new_literal (SYNCEVO_SERVER_ERROR_QUARK,
|
|
SYNCEVO_SERVER_ERROR_NO_DBUS_OBJECT,
|
|
"Could not start service");
|
|
(*(SyncevoServerGetConfigCb)data->callback) (data->server,
|
|
NULL,
|
|
error,
|
|
data->userdata);
|
|
server_async_data_free (data);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
syncevo_server_get_config (SyncevoServer *syncevo,
|
|
const char *config_name,
|
|
gboolean template,
|
|
SyncevoServerGetConfigCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (syncevo);
|
|
|
|
data = server_async_data_new (syncevo, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy && !syncevo_server_get_new_proxy (syncevo)) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)get_config_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_get_config_async
|
|
(priv->proxy,
|
|
config_name,
|
|
template,
|
|
(org_syncevolution_Server_get_config_reply) get_config_callback,
|
|
data);
|
|
}
|
|
|
|
static void
|
|
get_reports_callback (DBusGProxy *proxy,
|
|
SyncevoReports *reports,
|
|
GError *error,
|
|
ServerAsyncData *data)
|
|
{
|
|
if (data->callback) {
|
|
(*(SyncevoServerGetReportsCb)data->callback) (data->server,
|
|
reports,
|
|
error,
|
|
data->userdata);
|
|
}
|
|
server_async_data_free (data);
|
|
}
|
|
|
|
static gboolean
|
|
get_reports_error (ServerAsyncData *data)
|
|
{
|
|
GError *error;
|
|
|
|
error = g_error_new_literal (SYNCEVO_SERVER_ERROR_QUARK,
|
|
SYNCEVO_SERVER_ERROR_NO_DBUS_OBJECT,
|
|
"Could not start service");
|
|
(*(SyncevoServerGetReportsCb)data->callback) (data->server,
|
|
NULL,
|
|
error,
|
|
data->userdata);
|
|
server_async_data_free (data);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
syncevo_server_get_reports (SyncevoServer *syncevo,
|
|
const char *config_name,
|
|
guint start,
|
|
guint count,
|
|
SyncevoServerGetReportsCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (syncevo);
|
|
|
|
data = server_async_data_new (syncevo, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy && !syncevo_server_get_new_proxy (syncevo)) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)get_reports_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_get_reports_async
|
|
(priv->proxy,
|
|
config_name,
|
|
start,
|
|
count,
|
|
(org_syncevolution_Server_get_reports_reply) get_reports_callback,
|
|
data);
|
|
}
|
|
|
|
static void
|
|
start_session_callback (SyncevoServer *syncevo,
|
|
char *session_path,
|
|
GError *error,
|
|
ServerAsyncData *data)
|
|
{
|
|
if (data->callback) {
|
|
(*(SyncevoServerStartSessionCb)data->callback) (data->server,
|
|
session_path,
|
|
error,
|
|
data->userdata);
|
|
}
|
|
server_async_data_free (data);
|
|
}
|
|
|
|
static gboolean
|
|
start_session_error (ServerAsyncData *data)
|
|
{
|
|
GError *error;
|
|
|
|
error = g_error_new_literal (SYNCEVO_SERVER_ERROR_QUARK,
|
|
SYNCEVO_SERVER_ERROR_NO_DBUS_OBJECT,
|
|
"Could not start service");
|
|
(*(SyncevoServerStartSessionCb)data->callback) (data->server,
|
|
NULL,
|
|
error,
|
|
data->userdata);
|
|
server_async_data_free (data);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
syncevo_server_start_session (SyncevoServer *syncevo,
|
|
const char *config_name,
|
|
SyncevoServerStartSessionCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (syncevo);
|
|
|
|
data = server_async_data_new (syncevo, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy && !syncevo_server_get_new_proxy (syncevo)) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)start_session_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_start_session_async
|
|
(priv->proxy,
|
|
config_name,
|
|
(org_syncevolution_Server_start_session_reply) start_session_callback,
|
|
data);
|
|
}
|
|
|
|
void
|
|
syncevo_server_start_no_sync_session (SyncevoServer *syncevo,
|
|
const char *config_name,
|
|
SyncevoServerStartSessionCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
const char *flags[2] = {"no-sync", NULL};
|
|
|
|
priv = GET_PRIVATE (syncevo);
|
|
|
|
data = server_async_data_new (syncevo, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy && !syncevo_server_get_new_proxy (syncevo)) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)start_session_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_start_session_with_flags_async
|
|
(priv->proxy,
|
|
config_name,
|
|
flags,
|
|
(org_syncevolution_Server_start_session_reply) start_session_callback,
|
|
data);
|
|
}
|
|
|
|
static void
|
|
get_sessions_callback (SyncevoServer *syncevo,
|
|
SyncevoSessions *sessions,
|
|
GError *error,
|
|
ServerAsyncData *data)
|
|
{
|
|
if (data->callback) {
|
|
(*(SyncevoServerGetSessionsCb)data->callback) (data->server,
|
|
sessions,
|
|
error,
|
|
data->userdata);
|
|
}
|
|
server_async_data_free (data);
|
|
}
|
|
|
|
static gboolean
|
|
get_sessions_error (ServerAsyncData *data)
|
|
{
|
|
GError *error;
|
|
|
|
error = g_error_new_literal (SYNCEVO_SERVER_ERROR_QUARK,
|
|
SYNCEVO_SERVER_ERROR_NO_DBUS_OBJECT,
|
|
"Could not start service");
|
|
(*(SyncevoServerGetSessionsCb)data->callback) (data->server,
|
|
NULL,
|
|
error,
|
|
data->userdata);
|
|
server_async_data_free (data);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
syncevo_server_get_sessions (SyncevoServer *syncevo,
|
|
SyncevoServerGetSessionsCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (syncevo);
|
|
|
|
data = server_async_data_new (syncevo, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy && !syncevo_server_get_new_proxy (syncevo)) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)get_sessions_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_get_sessions_async
|
|
(priv->proxy,
|
|
(org_syncevolution_Server_get_reports_reply) get_sessions_callback,
|
|
data);
|
|
}
|
|
|
|
|
|
static void
|
|
check_presence_callback (SyncevoServer *syncevo,
|
|
char *status,
|
|
char **transports,
|
|
GError *error,
|
|
ServerAsyncData *data)
|
|
{
|
|
if (data->callback) {
|
|
(*(SyncevoServerGetPresenceCb)data->callback) (data->server,
|
|
status,
|
|
transports,
|
|
error,
|
|
data->userdata);
|
|
}
|
|
server_async_data_free (data);
|
|
}
|
|
|
|
static gboolean
|
|
check_presence_error (ServerAsyncData *data)
|
|
{
|
|
GError *error;
|
|
|
|
error = g_error_new_literal (SYNCEVO_SERVER_ERROR_QUARK,
|
|
SYNCEVO_SERVER_ERROR_NO_DBUS_OBJECT,
|
|
"Could not start service");
|
|
(*(SyncevoServerGetPresenceCb)data->callback) (data->server,
|
|
NULL,
|
|
NULL,
|
|
error,
|
|
data->userdata);
|
|
server_async_data_free (data);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void
|
|
syncevo_server_get_presence (SyncevoServer *syncevo,
|
|
const char *config_name,
|
|
SyncevoServerGetPresenceCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (syncevo);
|
|
|
|
data = server_async_data_new (syncevo, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy && !syncevo_server_get_new_proxy (syncevo)) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)check_presence_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_check_presence_async
|
|
(priv->proxy,
|
|
config_name,
|
|
(org_syncevolution_Server_check_presence_reply) check_presence_callback,
|
|
data);
|
|
}
|
|
|
|
void syncevo_server_check_source (SyncevoServer *server,
|
|
const char *config,
|
|
const char *source,
|
|
SyncevoServerGenericCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (server);
|
|
|
|
data = server_async_data_new (server, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)generic_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_check_source_async
|
|
(priv->proxy,
|
|
config,
|
|
source,
|
|
(org_syncevolution_Server_check_source_reply) generic_callback,
|
|
data);
|
|
}
|
|
|
|
void
|
|
syncevo_server_info_response (SyncevoServer *server,
|
|
const char *id,
|
|
const char *state,
|
|
GHashTable *response,
|
|
SyncevoServerGenericCb callback,
|
|
gpointer userdata)
|
|
{
|
|
ServerAsyncData *data;
|
|
SyncevoServerPrivate *priv;
|
|
|
|
priv = GET_PRIVATE (server);
|
|
|
|
data = server_async_data_new (server, G_CALLBACK (callback), userdata);
|
|
|
|
if (!priv->proxy) {
|
|
if (callback) {
|
|
g_idle_add ((GSourceFunc)generic_error, data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
org_syncevolution_Server_info_response_async
|
|
(priv->proxy,
|
|
id,
|
|
state,
|
|
response,
|
|
(org_syncevolution_Server_info_response_reply) generic_callback,
|
|
data);
|
|
}
|