src/dbus/syncevo-dbus.c

   1 /*
   2  * Copyright (C) 2009 Intel Corporation
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) version 3.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301  USA
  18  */
  19
  20 #include <glib-object.h>
  21 #include <string.h>
  22
  23 #include "syncevo-dbus.h"
  24 #include "syncevo-marshal.h"
  25 #include "syncevo-bindings.h"
  26
  27 typedef struct _SyncevoAsyncData {
  28         SyncevoService *service;
  29         GCallback callback;
  30         gpointer userdata;
  31 } SyncevoAsyncData;
  32
  33
  34 enum {
  35         PROGRESS,
  36         SERVER_MESSAGE,
  37         SERVER_SHUTDOWN,
  38         LAST_SIGNAL
  39 };
  40
  41 typedef struct _SyncevoServicePrivate {
  42         DBusGProxy *proxy;
  43 } SyncevoServicePrivate;
  44
  45 #define GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SYNCEVO_TYPE_SERVICE, SyncevoServicePrivate))
  46
  47 static void progress_cb (DBusGProxy *proxy,
  48                          char *server,
  49                          char *source,
  50                          int type,
  51                          int extra1, int extra2, int extra3,
  52                          SyncevoService *service);
  53 static void server_message_cb (DBusGProxy *proxy,
  54                                char *server,
  55                                char *message,
  56                                SyncevoService *service);
  57 static void proxy_destroyed (DBusGProxy *proxy,
  58                              SyncevoService *service);
  59
  60 G_DEFINE_TYPE (SyncevoService, syncevo_service, G_TYPE_OBJECT);
  61
  62 static guint32 signals[LAST_SIGNAL] = {0, };
  63
  64 static void
  65 finalize (GObject *object)
  66 {
  67         SyncevoServicePrivate *priv;
  68
  69         priv = GET_PRIVATE (object);
  70
  71         G_OBJECT_CLASS (syncevo_service_parent_class)->finalize (object);
  72 }
  73
  74 static void
  75 dispose (GObject *object)
  76 {
  77         SyncevoServicePrivate *priv;
  78
  79         priv = GET_PRIVATE (object);
  80
  81         if (priv->proxy) {
  82                 dbus_g_proxy_disconnect_signal (priv->proxy, "Progress",
  83                                                 G_CALLBACK (progress_cb),
  84                                                 object);
  85                 dbus_g_proxy_disconnect_signal (priv->proxy, "ServerMessage",
  86                                                 G_CALLBACK (server_message_cb),
  87                                                 object);
  88
  89                 g_object_unref (priv->proxy);
  90                 priv->proxy = NULL;
  91         }
  92
  93         G_OBJECT_CLASS (syncevo_service_parent_class)->dispose (object);
  94 }
  95
  96 static void progress_cb (DBusGProxy *proxy,
  97                          char *server,
  98                          char *source,
  99                          int type,
 100                          int extra1, int extra2, int extra3,
 101                          SyncevoService *service)
 102 {
 103         g_signal_emit (service, signals[PROGRESS], 0,
 104                        server, source, type, extra1, extra2, extra3);
 105 }
 106
 107 static void server_message_cb (DBusGProxy *proxy,
 108                                char *server,
 109                                char *message,
 110                                SyncevoService *service)
 111 {
 112         g_signal_emit (service, signals[SERVER_MESSAGE], 0,
 113                        server, message);
 114 }
 115
 116 static gboolean
 117 syncevo_service_get_new_proxy (SyncevoService *service)
 118 {
 119         DBusGConnection *connection;
 120         GError *error;
 121         guint32 result;
 122         SyncevoServicePrivate *priv;
 123         DBusGProxy *proxy;
 124
 125         priv = GET_PRIVATE (service);
 126         error = NULL;
 127
 128         connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
 129         if (connection == NULL) {
 130                 g_printerr ("Failed to open connection to bus: %s\n",
 131                             error->message);
 132                 g_error_free (error);
 133                 priv->proxy = NULL;
 134                 return FALSE;
 135         }
 136
 137         /* we want to use dbus_g_proxy_new_for_name_owner() for the destroy signal
 138          * so need to start the service by hand by using DBUS proxy: */
 139         proxy = dbus_g_proxy_new_for_name (connection,
 140                                            DBUS_SERVICE_DBUS,
 141                                            DBUS_PATH_DBUS,
 142                                            DBUS_INTERFACE_DBUS);
 143         if (!dbus_g_proxy_call (proxy, "StartServiceByName", NULL,
 144                                 G_TYPE_STRING, SYNCEVO_SERVICE_DBUS_SERVICE,
 145                                 G_TYPE_UINT, 0,
 146                                 G_TYPE_INVALID,
 147                                 G_TYPE_UINT, &result,
 148                                 G_TYPE_INVALID)) {
 149                 g_warning ("StartServiceByName call failed");
 150         }
 151         g_object_unref (proxy);
 152
 153         /* the real proxy */
 154         proxy = dbus_g_proxy_new_for_name_owner (connection,
 155                                                  SYNCEVO_SERVICE_DBUS_SERVICE,
 156                                                  SYNCEVO_SERVICE_DBUS_PATH,
 157                                                  SYNCEVO_SERVICE_DBUS_INTERFACE,
 158                                                  &error);
 159         if (proxy == NULL) {
 160                 g_printerr ("dbus_g_proxy_new_for_name_owner() failed");
 161                 priv->proxy = NULL;
 162                 return FALSE;
 163         }
 164
 165         dbus_g_proxy_add_signal (proxy, "Progress",
 166                                  G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INVALID);
 167         dbus_g_proxy_connect_signal (proxy, "Progress",
 168                                      G_CALLBACK (progress_cb), service, NULL);
 169         dbus_g_proxy_add_signal (proxy, "ServerMessage",
 170                                  G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
 171         dbus_g_proxy_connect_signal (proxy, "ServerMessage",
 172                                      G_CALLBACK (server_message_cb), service, NULL);
 173
 174         g_signal_connect (proxy, "destroy",
 175                           G_CALLBACK (proxy_destroyed), service);
 176
 177         priv->proxy = proxy;
 178         return TRUE;
 179 }
 180
 181 static void
 182 proxy_destroyed (DBusGProxy *proxy,
 183                  SyncevoService *service)
 184 {
 185         SyncevoServicePrivate *priv;
 186         priv = GET_PRIVATE (service);
 187
 188         if (priv->proxy) {
 189                 g_object_unref (priv->proxy);
 190         }
 191         priv->proxy = NULL;
 192
 193         g_signal_emit (service, signals[SERVER_SHUTDOWN], 0);
 194 }
 195
 196 static GObject *
 197 constructor (GType                  type,
 198              guint                  n_construct_properties,
 199              GObjectConstructParam *construct_properties)
 200 {
 201         SyncevoService *service;
 202         SyncevoServicePrivate *priv;
 203
 204         service = SYNCEVO_SERVICE (G_OBJECT_CLASS (syncevo_service_parent_class)->constructor
 205                         (type, n_construct_properties, construct_properties));
 206         priv = GET_PRIVATE (service);
 207
 208         dbus_g_object_register_marshaller (syncevo_marshal_VOID__STRING_STRING_INT_INT_INT_INT,
 209                                            G_TYPE_NONE,
 210                                            G_TYPE_STRING,
 211                                            G_TYPE_STRING,
 212                                            G_TYPE_INT,
 213                                            G_TYPE_INT,
 214                                            G_TYPE_INT,
 215                                            G_TYPE_INT,
 216                                            G_TYPE_INVALID);
 217         dbus_g_object_register_marshaller (syncevo_marshal_VOID__STRING_STRING,
 218                                            G_TYPE_NONE,
 219                                            G_TYPE_STRING,
 220                                            G_TYPE_STRING,
 221                                            G_TYPE_INVALID);
 222
 223         syncevo_service_get_new_proxy (service);
 224
 225         return G_OBJECT (service);
 226 }
 227
 228 static void
 229 syncevo_service_class_init (SyncevoServiceClass *klass)
 230 {
 231         GObjectClass *o_class = (GObjectClass *) klass;
 232
 233         o_class->finalize = finalize;
 234         o_class->dispose = dispose;
 235         o_class->constructor = constructor;
 236
 237         g_type_class_add_private (klass, sizeof (SyncevoServicePrivate));
 238
 239         signals[PROGRESS] = g_signal_new ("progress",
 240                                           G_TYPE_FROM_CLASS (klass),
 241                                           G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 242                                           G_STRUCT_OFFSET (SyncevoServiceClass, progress),
 243                                           NULL, NULL,
 244                                           syncevo_marshal_VOID__STRING_STRING_INT_INT_INT_INT,
 245                                           G_TYPE_NONE,
 246                                           6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);
 247         signals[SERVER_MESSAGE] = g_signal_new ("server-message",
 248                                           G_TYPE_FROM_CLASS (klass),
 249                                           G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 250                                           G_STRUCT_OFFSET (SyncevoServiceClass, server_message),
 251                                           NULL, NULL,
 252                                           syncevo_marshal_VOID__STRING_STRING,
 253                                           G_TYPE_NONE,
 254                                           2, G_TYPE_STRING, G_TYPE_STRING);
 255         signals[SERVER_SHUTDOWN] = g_signal_new ("server-shutdown",
 256                                           G_TYPE_FROM_CLASS (klass),
 257                                           G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 258                                           G_STRUCT_OFFSET (SyncevoServiceClass, server_shutdown),
 259                                           NULL, NULL,
 260                                           g_cclosure_marshal_VOID__VOID,
 261                                           G_TYPE_NONE,
 262                                           0);
 263 }
 264
 265 static void
 266 syncevo_service_init (SyncevoService *service)
 267 {
 268 }
 269
 270
 271 SyncevoService *
 272 syncevo_service_get_default ()
 273 {
 274         static SyncevoService *default_service = NULL;
 275
 276         if (default_service == NULL) {
 277                 default_service = g_object_new (SYNCEVO_TYPE_SERVICE, NULL);
 278                 g_object_add_weak_pointer (G_OBJECT (default_service),
 279                                            (gpointer) &default_service);
 280                 return default_service;
 281         }
 282
 283         return g_object_ref (default_service);
 284 }
 285
 286
 287
 288 gboolean syncevo_service_start_sync (SyncevoService *service,
 289                                      char *server,
 290                                      GPtrArray *sources,
 291                                      GError **error)
 292 {
 293         SyncevoServicePrivate *priv;
 294
 295         priv = GET_PRIVATE (service);
 296
 297         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 298                 if (error) {
 299                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 300                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 301                                                       "Could not start service");
 302                 }
 303                 return FALSE;
 304         }
 305
 306         return org_Moblin_SyncEvolution_start_sync (priv->proxy,
 307                                                     server,
 308                                                     sources,
 309                                                     error);
 310 }
 311
 312 gboolean syncevo_service_abort_sync (SyncevoService *service,
 313                                      char *server,
 314                                      GError **error)
 315 {
 316         SyncevoServicePrivate *priv;
 317
 318         priv = GET_PRIVATE (service);
 319
 320         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 321                 if (error) {
 322                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 323                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 324                                                       "Could not start service");
 325                 }
 326                 return FALSE;
 327         }
 328
 329         return org_Moblin_SyncEvolution_abort_sync (priv->proxy,
 330                                                     server,
 331                                                     error);
 332 }
 333
 334 static void
 335 abort_sync_async_callback (DBusGProxy *proxy,
 336                            GError *error,
 337                            SyncevoAsyncData *data)
 338 {
 339         (*(SyncevoAbortSyncCb)data->callback) (data->service,
 340                                                error,
 341                                                data->userdata);
 342         g_slice_free (SyncevoAsyncData, data);
 343 }
 344
 345 static void
 346 abort_sync_async_error (SyncevoAsyncData *data)
 347 {
 348         GError *error;
 349
 350         error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 351                                                                  SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 352                                                                  "Could not start service");
 353         (*(SyncevoAbortSyncCb)data->callback) (data->service,
 354                                                error,
 355                                                data->userdata);
 356         g_slice_free (SyncevoAsyncData, data);
 357 }
 358
 359 void
 360 syncevo_service_abort_sync_async (SyncevoService *service,
 361                                   char *server,
 362                                   SyncevoAbortSyncCb callback,
 363                                   gpointer userdata)
 364 {
 365         SyncevoAsyncData *data;
 366         SyncevoServicePrivate *priv;
 367
 368         priv = GET_PRIVATE (service);
 369
 370         data = g_slice_new0 (SyncevoAsyncData);
 371         data->service = service;
 372         data->callback = G_CALLBACK (callback);
 373         data->userdata = userdata;
 374
 375         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 376                 g_idle_add ((GSourceFunc)abort_sync_async_error, data);
 377                 return;
 378         }
 379
 380         org_Moblin_SyncEvolution_abort_sync_async
 381                         (priv->proxy,
 382                          server,
 383                          (org_Moblin_SyncEvolution_abort_sync_reply) abort_sync_async_callback,
 384                          data);
 385 }
 386
 387
 388 gboolean syncevo_service_get_servers (SyncevoService *service,
 389                                       GPtrArray **servers,
 390                                       GError **error)
 391 {
 392         SyncevoServicePrivate *priv;
 393
 394         priv = GET_PRIVATE (service);
 395
 396         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 397                 if (error) {
 398                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 399                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 400                                                       "Could not start service");
 401                 }
 402                 return FALSE;
 403         }
 404
 405         return org_Moblin_SyncEvolution_get_servers (priv->proxy,
 406                                                      servers,
 407                                                      error);
 408 }
 409
 410 static void
 411 get_servers_async_callback (DBusGProxy *proxy,
 412                             GPtrArray *servers,
 413                             GError *error,
 414                             SyncevoAsyncData *data)
 415 {
 416         (*(SyncevoGetServersCb)data->callback) (data->service,
 417                                                 servers,
 418                                                 error,
 419                                                 data->userdata);
 420         g_slice_free (SyncevoAsyncData, data);
 421 }
 422
 423 static void
 424 get_servers_async_error (SyncevoAsyncData *data)
 425 {
 426         GError *error;
 427
 428         error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 429                                                                  SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 430                                                                  "Could not start service");
 431         (*(SyncevoGetServersCb)data->callback) (data->service,
 432                                                 NULL,
 433                                                 error,
 434                                                 data->userdata);
 435         g_slice_free (SyncevoAsyncData, data);
 436 }
 437
 438 void
 439 syncevo_service_get_servers_async (SyncevoService *service,
 440                                    SyncevoGetServersCb callback,
 441                                    gpointer userdata)
 442 {
 443         SyncevoAsyncData *data;
 444         SyncevoServicePrivate *priv;
 445
 446         priv = GET_PRIVATE (service);
 447
 448         data = g_slice_new0 (SyncevoAsyncData);
 449         data->service = service;
 450         data->callback = G_CALLBACK (callback);
 451         data->userdata = userdata;
 452
 453         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 454                 g_idle_add ((GSourceFunc)get_servers_async_error, data);
 455                 return;
 456         }
 457
 458         org_Moblin_SyncEvolution_get_servers_async
 459                         (priv->proxy,
 460                          (org_Moblin_SyncEvolution_get_servers_reply) get_servers_async_callback,
 461                          data);
 462 }
 463
 464 gboolean syncevo_service_get_templates (SyncevoService *service,
 465                                         GPtrArray **templates,
 466                                         GError **error)
 467 {
 468         SyncevoServicePrivate *priv;
 469
 470         priv = GET_PRIVATE (service);
 471
 472         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 473                 if (error) {
 474                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 475                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 476                                                       "Could not start service");
 477                 }
 478                 return FALSE;
 479         }
 480
 481         return org_Moblin_SyncEvolution_get_templates (priv->proxy,
 482                                                        templates,
 483                                                        error);
 484 }
 485
 486 static void
 487 get_templates_async_callback (DBusGProxy *proxy,
 488                               GPtrArray *templates,
 489                               GError *error,
 490                               SyncevoAsyncData *data)
 491 {
 492         (*(SyncevoGetTemplatesCb)data->callback) (data->service,
 493                                                   templates,
 494                                                   error,
 495                                                   data->userdata);
 496         g_slice_free (SyncevoAsyncData, data);
 497 }
 498
 499 static void
 500 get_templates_async_error (SyncevoAsyncData *data)
 501 {
 502         GError *error;
 503
 504         error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 505                                                                  SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 506                                                                  "Could not start service");
 507         (*(SyncevoGetTemplatesCb)data->callback) (data->service,
 508                                                   NULL,
 509                                                   error,
 510                                                   data->userdata);
 511         g_slice_free (SyncevoAsyncData, data);
 512 }
 513
 514 void syncevo_service_get_templates_async (SyncevoService *service,
 515                                           SyncevoGetTemplatesCb callback,
 516                                           gpointer userdata)
 517 {
 518         SyncevoAsyncData *data;
 519         SyncevoServicePrivate *priv;
 520
 521         priv = GET_PRIVATE (service);
 522
 523         data = g_slice_new0 (SyncevoAsyncData);
 524         data->service = service;
 525         data->callback = G_CALLBACK (callback);
 526         data->userdata = userdata;
 527
 528         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 529                 g_idle_add ((GSourceFunc)get_templates_async_error, data);
 530                 return;
 531         }
 532
 533         org_Moblin_SyncEvolution_get_templates_async
 534                         (priv->proxy,
 535                          (org_Moblin_SyncEvolution_get_templates_reply) get_templates_async_callback,
 536                          data);
 537 }
 538
 539 gboolean syncevo_service_get_template_config (SyncevoService *service,
 540                                               char *template,
 541                                               GPtrArray **options,
 542                                               GError **error)
 543 {
 544         SyncevoServicePrivate *priv;
 545
 546         priv = GET_PRIVATE (service);
 547
 548         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 549                 if (error) {
 550                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 551                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 552                                                       "Could not start service");
 553                 }
 554                 return FALSE;
 555         }
 556
 557         return org_Moblin_SyncEvolution_get_template_config (priv->proxy,
 558                                                              template,
 559                                                              options,
 560                                                              error);
 561 }
 562
 563 static void
 564 get_template_config_async_callback (DBusGProxy *proxy,
 565                                     GPtrArray *options,
 566                                     GError *error,
 567                                     SyncevoAsyncData *data)
 568 {
 569         (*(SyncevoGetTemplateConfigCb)data->callback) (data->service,
 570                                                        options,
 571                                                        error,
 572                                                        data->userdata);
 573         g_slice_free (SyncevoAsyncData, data);
 574 }
 575
 576 static void
 577 get_template_config_async_error (SyncevoAsyncData *data)
 578 {
 579         GError *error;
 580
 581         error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 582                                                                  SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 583                                                                  "Could not start service");
 584         (*(SyncevoGetTemplateConfigCb)data->callback) (data->service,
 585                                                        NULL,
 586                                                        error,
 587                                                        data->userdata);
 588         g_slice_free (SyncevoAsyncData, data);
 589 }
 590
 591 void
 592 syncevo_service_get_template_config_async (SyncevoService *service,
 593                                            char *template,
 594                                            SyncevoGetServerConfigCb callback,
 595                                            gpointer userdata)
 596 {
 597         SyncevoAsyncData *data;
 598         SyncevoServicePrivate *priv;
 599
 600         priv = GET_PRIVATE (service);
 601
 602         data = g_slice_new0 (SyncevoAsyncData);
 603         data->service = service;
 604         data->callback = G_CALLBACK (callback);
 605         data->userdata = userdata;
 606
 607         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 608                 g_idle_add ((GSourceFunc)get_template_config_async_error, data);
 609                 return;
 610         }
 611
 612         org_Moblin_SyncEvolution_get_template_config_async
 613                         (priv->proxy,
 614                          template,
 615                          (org_Moblin_SyncEvolution_get_server_config_reply) get_template_config_async_callback,
 616                          data);
 617 }
 618
 619 gboolean syncevo_service_get_server_config (SyncevoService *service,
 620                                             char *server,
 621                                             GPtrArray **options,
 622                                             GError **error)
 623 {
 624         SyncevoServicePrivate *priv;
 625
 626         priv = GET_PRIVATE (service);
 627
 628         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 629                 if (error) {
 630                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 631                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 632                                                       "Could not start service");
 633                 }
 634                 return FALSE;
 635         }
 636
 637         return org_Moblin_SyncEvolution_get_server_config (priv->proxy,
 638                                                            server,
 639                                                            options,
 640                                                            error);
 641 }
 642
 643 static void
 644 get_server_config_async_callback (DBusGProxy *proxy,
 645                                   GPtrArray *options,
 646                                   GError *error,
 647                                   SyncevoAsyncData *data)
 648 {
 649         (*(SyncevoGetServerConfigCb)data->callback) (data->service,
 650                                                      options,
 651                                                      error,
 652                                                      data->userdata);
 653         g_slice_free (SyncevoAsyncData, data);
 654 }
 655
 656 static void
 657 get_server_config_async_error (SyncevoAsyncData *data)
 658 {
 659         GError *error;
 660
 661         error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 662                                                                  SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 663                                                                  "Could not start service");
 664         (*(SyncevoGetServerConfigCb)data->callback) (data->service,
 665                                                      NULL,
 666                                                      error,
 667                                                      data->userdata);
 668         g_slice_free (SyncevoAsyncData, data);
 669 }
 670
 671 void
 672 syncevo_service_get_server_config_async (SyncevoService *service,
 673                                          char *server,
 674                                          SyncevoGetServerConfigCb callback,
 675                                          gpointer userdata)
 676 {
 677         SyncevoAsyncData *data;
 678         SyncevoServicePrivate *priv;
 679
 680         priv = GET_PRIVATE (service);
 681
 682         data = g_slice_new0 (SyncevoAsyncData);
 683         data->service = service;
 684         data->callback = G_CALLBACK (callback);
 685         data->userdata = userdata;
 686
 687         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 688                 g_idle_add ((GSourceFunc)get_server_config_async_error, data);
 689                 return;
 690         }
 691
 692         org_Moblin_SyncEvolution_get_server_config_async
 693                         (priv->proxy,
 694                          server,
 695                          (org_Moblin_SyncEvolution_get_server_config_reply) get_server_config_async_callback,
 696                          data);
 697 }
 698
 699
 700 gboolean syncevo_service_set_server_config (SyncevoService *service,
 701                                             char *server,
 702                                             GPtrArray *options,
 703                                             GError **error)
 704 {
 705         SyncevoServicePrivate *priv;
 706
 707         priv = GET_PRIVATE (service);
 708
 709         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 710                 if (error) {
 711                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 712                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 713                                                       "Could not start service");
 714                 }
 715                 return FALSE;
 716         }
 717
 718         return org_Moblin_SyncEvolution_set_server_config (priv->proxy,
 719                                                            server,
 720                                                            options,
 721                                                            error);
 722 }
 723
 724 static void
 725 set_server_config_async_callback (DBusGProxy *proxy,
 726                                   GError *error,
 727                                   SyncevoAsyncData *data)
 728 {
 729         (*(SyncevoSetServerConfigCb)data->callback) (data->service,
 730                                                      error,
 731                                                      data->userdata);
 732         g_slice_free (SyncevoAsyncData, data);
 733 }
 734
 735 static void
 736 set_server_config_async_error (SyncevoAsyncData *data)
 737 {
 738         GError *error;
 739
 740         error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 741                                                                  SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 742                                                                  "Could not start service");
 743         (*(SyncevoSetServerConfigCb)data->callback) (data->service,
 744                                                      error,
 745                                                      data->userdata);
 746         g_slice_free (SyncevoAsyncData, data);
 747 }
 748
 749 void
 750 syncevo_service_set_server_config_async (SyncevoService *service,
 751                                          char *server,
 752                                          GPtrArray *options,
 753                                          SyncevoSetServerConfigCb callback,
 754                                          gpointer userdata)
 755 {
 756         SyncevoAsyncData *data;
 757         SyncevoServicePrivate *priv;
 758
 759         priv = GET_PRIVATE (service);
 760
 761         data = g_slice_new0 (SyncevoAsyncData);
 762         data->service = service;
 763         data->callback = G_CALLBACK (callback);
 764         data->userdata = userdata;
 765
 766         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 767                 g_idle_add ((GSourceFunc)set_server_config_async_error, data);
 768                 return;
 769         }
 770
 771         org_Moblin_SyncEvolution_set_server_config_async
 772                         (priv->proxy,
 773                          server,
 774                          options,
 775                          (org_Moblin_SyncEvolution_set_server_config_reply) set_server_config_async_callback,
 776                          data);
 777 }
 778
 779 gboolean
 780 syncevo_service_remove_server_config (SyncevoService *service,
 781                                       char *server,
 782                                       GError **error)
 783 {
 784         SyncevoServicePrivate *priv;
 785
 786         priv = GET_PRIVATE (service);
 787
 788         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 789                 if (error) {
 790                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 791                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 792                                                       "Could not start service");
 793                 }
 794                 return FALSE;
 795         }
 796
 797         return org_Moblin_SyncEvolution_remove_server_config (priv->proxy,
 798                                                               server,
 799                                                               error);
 800 }
 801
 802 static void
 803 remove_server_config_async_callback (DBusGProxy *proxy,
 804                                      GError *error,
 805                                      SyncevoAsyncData *data)
 806 {
 807         (*(SyncevoRemoveServerConfigCb)data->callback) (data->service,
 808                                                      error,
 809                                                      data->userdata);
 810         g_slice_free (SyncevoAsyncData, data);
 811 }
 812
 813 static void
 814 remove_server_config_async_error (SyncevoAsyncData *data)
 815 {
 816         GError *error;
 817
 818         error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 819                                                                  SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 820                                                                  "Could not start service");
 821         (*(SyncevoRemoveServerConfigCb)data->callback) (data->service,
 822                                                         error,
 823                                                         data->userdata);
 824         g_slice_free (SyncevoAsyncData, data);
 825 }
 826
 827 void
 828 syncevo_service_remove_server_config_async (SyncevoService *service,
 829                                             char *server,
 830                                             SyncevoRemoveServerConfigCb callback,
 831                                             gpointer userdata)
 832 {
 833         SyncevoAsyncData *data;
 834         SyncevoServicePrivate *priv;
 835
 836         priv = GET_PRIVATE (service);
 837
 838         data = g_slice_new0 (SyncevoAsyncData);
 839         data->service = service;
 840         data->callback = G_CALLBACK (callback);
 841         data->userdata = userdata;
 842
 843         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 844                 g_idle_add ((GSourceFunc)remove_server_config_async_error, data);
 845                 return;
 846         }
 847
 848         org_Moblin_SyncEvolution_remove_server_config_async
 849                         (priv->proxy,
 850                          server,
 851                          (org_Moblin_SyncEvolution_remove_server_config_reply) remove_server_config_async_callback,
 852                          data);
 853 }
 854
 855 gboolean
 856 syncevo_service_get_sync_reports (SyncevoService *service,
 857                                   char *server,
 858                                   int count,
 859                                   GPtrArray **reports,
 860                                   GError **error)
 861 {
 862         SyncevoServicePrivate *priv;
 863
 864         priv = GET_PRIVATE (service);
 865
 866         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 867                 if (error) {
 868                         *error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 869                                                       SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 870                                                       "Could not start service");
 871                 }
 872                 return FALSE;
 873         }
 874
 875         return org_Moblin_SyncEvolution_get_sync_reports (
 876                         priv->proxy,
 877                         server,
 878                         count,
 879                         reports,
 880                         error);
 881 }
 882
 883 static void
 884 get_sync_reports_async_callback (DBusGProxy *proxy,
 885                                  GPtrArray *reports,
 886                                  GError *error,
 887                                  SyncevoAsyncData *data)
 888 {
 889         (*(SyncevoGetSyncReportsCb)data->callback) (data->service,
 890                                                     reports,
 891                                                     error,
 892                                                     data->userdata);
 893         g_slice_free (SyncevoAsyncData, data);
 894 }
 895
 896 static void
 897 get_sync_reports_async_error (SyncevoAsyncData *data)
 898 {
 899         GError *error;
 900
 901         error = g_error_new_literal (g_quark_from_static_string ("syncevo-service"),
 902                                                                  SYNCEVO_SERVICE_ERROR_COULD_NOT_START,
 903                                                                  "Could not start service");
 904         (*(SyncevoGetSyncReportsCb)data->callback) (data->service,
 905                                                     NULL,
 906                                                     error,
 907                                                     data->userdata);
 908         g_slice_free (SyncevoAsyncData, data);
 909 }
 910
 911 void
 912 syncevo_service_get_sync_reports_async (SyncevoService *service,
 913                                        char *server,
 914                                        int count,
 915                                        SyncevoGetSyncReportsCb callback,
 916                                        gpointer userdata)
 917 {
 918         SyncevoAsyncData *data;
 919         SyncevoServicePrivate *priv;
 920
 921         priv = GET_PRIVATE (service);
 922
 923         data = g_slice_new0 (SyncevoAsyncData);
 924         data->service = service;
 925         data->callback = G_CALLBACK (callback);
 926         data->userdata = userdata;
 927
 928         if (!priv->proxy && !syncevo_service_get_new_proxy (service)) {
 929                 g_idle_add ((GSourceFunc)get_sync_reports_async_error, data);
 930                 return;
 931         }
 932
 933         org_Moblin_SyncEvolution_get_sync_reports_async
 934                         (priv->proxy,
 935                          server,
 936                          count,
 937                          (org_Moblin_SyncEvolution_get_sync_reports_reply) get_sync_reports_async_callback,
 938                          data);
 939 }