client/cal_client_dbus.c

   1 /*
   2  * Calendar Service
   3  *
   4  * Copyright (c) 2012 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <stdbool.h>
  23 #include <gio/gio.h>
  24 #include <sys/time.h>
  25
  26 #include "cal_internal.h"
  27 #include "cal_typedef.h"
  28 #include "cal_view.h"
  29 #include "cal_dbus_helper.h"
  30 #include "cal_dbus.h"
  31 #include "cal_list.h"
  32 #include "cal_client_handle.h"
  33 #include "cal_client_reminder.h"
  34 #include "cal_client_db_helper.h"
  35
  36 #define __CAL_CLIENT_ACCESS_MAX 10
  37 #define __CAL_CLIENT_ALLOW_USEC 25000
  38 #define CAL_LIMIT_ACCESS_FRONT(uri) \
  39         DBG("uri[%s]", uri); \
  40         int is_schedule = 0; \
  41         do { \
  42                 if (CAL_STRING_EQUAL == strncmp(uri, CALENDAR_VIEW_EVENT, strlen(CALENDAR_VIEW_EVENT))) { \
  43                         is_schedule = 1; \
  44                         struct timeval hold = {0}; \
  45                         struct timeval diff = {0}; \
  46                         gettimeofday(&hold, NULL); \
  47                         timersub(&hold, &__g_release_time, &diff); \
  48                         DBG("%ld.%ld sec", diff.tv_sec, diff.tv_usec); \
  49                         if (diff.tv_sec / 1000 == 0 && diff.tv_usec < __CAL_CLIENT_ALLOW_USEC) { \
  50                                 if (__g_access_count < __CAL_CLIENT_ACCESS_MAX) { \
  51                                         __g_access_count++; \
  52                                         DBG("--count (%d)", __g_access_count); \
  53                                 } else { \
  54                                         DBG("--sleep"); \
  55                                         usleep(200000); \
  56                                         __g_access_count = 0; \
  57                                         timerclear(&__g_release_time); \
  58                                 } \
  59                         } else { \
  60                                 DBG("--reset"); \
  61                                 __g_access_count = 0; \
  62                                 timerclear(&__g_release_time); \
  63                         } \
  64                 } \
  65         } while (0)
  66
  67 #define CAL_LIMIT_ACCESS_BACK \
  68         do { \
  69                 if (is_schedule) { \
  70                         gettimeofday(&__g_release_time, NULL); \
  71                 } \
  72         } while (0)
  73
  74 static int __g_access_count = 0;
  75 static struct timeval __g_release_time;
  76
  77 static calDbus *cal_dbus_object;
  78
  79 static void _cal_dbus_cleanup(void)
  80 {
  81         CAL_FN_CALL();
  82 }
  83
  84 static void _cal_dbus_name_owner_notify(GObject *object, GParamSpec *pspec, gpointer user_data)
  85 {
  86         CAL_FN_CALL();
  87
  88         GDBusProxy *proxy = G_DBUS_PROXY(object);
  89         gchar *name_owner = g_dbus_proxy_get_name_owner(proxy);
  90
  91         if (name_owner) {
  92                 DBG("name_owner[%s]", name_owner);
  93                 return;
  94         }
  95
  96         _cal_dbus_cleanup();
  97 }
  98
  99 void cal_dbus_call_reminder_cb(GDBusConnection *connection,
 100                 const gchar *sender_name,
 101                 const gchar *object_path,
 102                 const gchar *interface_name,
 103                 const gchar *signal_name,
 104                 GVariant *parameters,
 105                 gpointer user_data)
 106 {
 107         CAL_FN_CALL();
 108
 109         int stream_size = 0;
 110         char *stream = NULL;
 111         cal_dbus_utils_gvariant_to_stream(parameters, &stream_size, &stream);
 112         DBG("stream[%s]", stream);
 113         cal_client_reminder_call_subscribe(stream);
 114 }
 115
 116 unsigned int cal_dbus_subscribe_signal(char *signal_name, GDBusSignalCallback callback,
 117                  gpointer user_data, GDestroyNotify user_data_free_func)
 118 {
 119         GDBusConnection *conn = g_dbus_proxy_get_connection(G_DBUS_PROXY(cal_dbus_object));
 120
 121         return g_dbus_connection_signal_subscribe(conn,
 122                         NULL,
 123                         CAL_DBUS_INTERFACE,
 124                         signal_name,
 125                         CAL_DBUS_OBJPATH,
 126                         NULL,
 127                         G_DBUS_SIGNAL_FLAGS_NONE,
 128                         callback,
 129                         user_data,
 130                         user_data_free_func);
 131 }
 132
 133 void cal_dbus_unsubscribe_signal(unsigned int id)
 134 {
 135         GDBusConnection *conn = g_dbus_proxy_get_connection(G_DBUS_PROXY(cal_dbus_object));
 136         g_dbus_connection_signal_unsubscribe(conn, id);
 137 }
 138
 139 static int _register_resource(void)
 140 {
 141         GError *error = NULL;
 142         int ret = 0;
 143
 144         cal_dbus_call_register_resource_sync(cal_dbus_object, &ret, NULL, &error);
 145         if (error) {
 146                 ERR("cal_dbus_call_register_resource_sync() Fail[%s]", error->message);
 147                 g_error_free(error);
 148                 return CALENDAR_ERROR_IPC;
 149         }
 150         return ret;
 151 }
 152
 153 static int _unregister_resource(void)
 154 {
 155         GError *error = NULL;
 156         int ret = 0;
 157
 158         cal_dbus_call_unregister_resource_sync(cal_dbus_object, &ret, NULL, &error);
 159         if (error) {
 160                 ERR("cal_dbus_call_register_resource_sync() Fail[%s]", error->message);
 161                 g_error_free(error);
 162                 return CALENDAR_ERROR_IPC;
 163         }
 164         return ret;
 165 }
 166
 167 int cal_dbus_start(void)
 168 {
 169         if (cal_dbus_object) {
 170                 DBG("Already exists");
 171                 return CALENDAR_ERROR_NONE;
 172         }
 173
 174         GError *error = NULL;
 175         cal_dbus_object = cal_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION,
 176                         G_DBUS_PROXY_FLAGS_NONE,
 177                         CAL_DBUS_INTERFACE,
 178                         CAL_DBUS_OBJPATH,
 179                         NULL,
 180                         &error);
 181         if (NULL == cal_dbus_object) {
 182                 ERR("cal_dbus_proxy_new_for_bus_sync() Fail");
 183                 if (error) {
 184                         ERR("error[%s]", error->message);
 185                         g_error_free(error);
 186                 }
 187                 return CALENDAR_ERROR_IPC;
 188         }
 189
 190         _register_resource();
 191
 192         unsigned int id;
 193         id = g_signal_connect(cal_dbus_object, "notify::g-name-owner",
 194                         G_CALLBACK(_cal_dbus_name_owner_notify), NULL);
 195         if (0 == id) {
 196                 ERR("g_signal_connect() Fail");
 197                 return CALENDAR_ERROR_IPC;
 198         }
 199
 200         return CALENDAR_ERROR_NONE;
 201 }
 202
 203 int cal_dbus_stop(void)
 204 {
 205         if (NULL == cal_dbus_object) {
 206                 ERR("No object");
 207                 return CALENDAR_ERROR_NONE;
 208         }
 209
 210         DBG("[ALL CONNECTION IS CLOSED]");
 211
 212         _unregister_resource();
 213         _cal_dbus_cleanup();
 214
 215         g_object_unref(cal_dbus_object);
 216         cal_dbus_object = NULL;
 217
 218         return CALENDAR_ERROR_NONE;
 219 }
 220
 221 int cal_dbus_recovery(void)
 222 {
 223         CAL_FN_CALL();
 224
 225         if (cal_dbus_object) {
 226                 DBG("unref");
 227                 g_object_unref(cal_dbus_object);
 228                 cal_dbus_object = NULL;
 229         }
 230
 231         GError *error = NULL;
 232         cal_dbus_object = cal_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION,
 233                         G_DBUS_PROXY_FLAGS_NONE,
 234                         CAL_DBUS_INTERFACE,
 235                         CAL_DBUS_OBJPATH,
 236                         NULL,
 237                         &error);
 238         if (NULL == cal_dbus_object) {
 239                 ERR("cal_dbus_proxy_new_for_bus_sync() Fail");
 240                 if (error) {
 241                         ERR("error[%s]", error->message);
 242                         g_error_free(error);
 243                 }
 244                 return CALENDAR_ERROR_IPC;
 245         }
 246
 247         unsigned int id;
 248         id = g_signal_connect(cal_dbus_object, "notify::g-name-owner",
 249                         G_CALLBACK(_cal_dbus_name_owner_notify), NULL);
 250         if (0 == id) {
 251                 ERR("g_signal_connect() Fail");
 252                 return CALENDAR_ERROR_IPC;
 253         }
 254
 255         return CALENDAR_ERROR_NONE;
 256 }
 257
 258 int cal_dbus_insert_record(calendar_h handle, calendar_record_h record, int *out_id)
 259 {
 260         GError *error = NULL;
 261         int ret = 0;
 262         int version = 0;
 263         int id = 0;
 264
 265         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 266         RETV_IF(NULL == record, CALENDAR_ERROR_INVALID_PARAMETER);
 267         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 268
 269         CAL_RECORD_RESET_COMMON((cal_record_s *)record);
 270         CAL_LIMIT_ACCESS_FRONT(((cal_record_s *)record)->view_uri);
 271
 272         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 273         GVariant *arg_record = cal_dbus_utils_record_to_gvariant(record);
 274         cal_dbus_call_insert_record_sync(cal_dbus_object, arg_handle, arg_record,
 275                         &id, &version, &ret, NULL, &error);
 276         g_variant_unref(arg_record);
 277         g_variant_unref(arg_handle);
 278         if (error) {
 279                 ERR("cal_dbus_call_insert_record_sync() Fail[%s]", error->message);
 280                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 281                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 282                 else
 283                         ret = CALENDAR_ERROR_IPC;
 284                 g_error_free(error);
 285                 return ret;
 286         }
 287         cal_client_handle_set_version(handle, version);
 288         if (out_id)
 289                 *out_id = id;
 290
 291         CAL_LIMIT_ACCESS_BACK;
 292         return ret;
 293 }
 294
 295 int cal_dbus_update_record(calendar_h handle, calendar_record_h record)
 296 {
 297         GError *error = NULL;
 298         int ret = 0;
 299         int version = 0;
 300
 301         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 302         RETV_IF(NULL == record, CALENDAR_ERROR_INVALID_PARAMETER);
 303         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 304
 305         CAL_LIMIT_ACCESS_FRONT(((cal_record_s *)record)->view_uri);
 306
 307         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 308         GVariant *arg_record = cal_dbus_utils_record_to_gvariant(record);
 309         cal_dbus_call_update_record_sync(cal_dbus_object, arg_handle, arg_record,
 310                         &version, &ret, NULL, &error);
 311         g_variant_unref(arg_record);
 312         g_variant_unref(arg_handle);
 313         if (error) {
 314                 ERR("cal_dbus_call_update_record_sync() Fail[%s]", error->message);
 315                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 316                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 317                 else
 318                         ret = CALENDAR_ERROR_IPC;
 319                 g_error_free(error);
 320                 return ret;
 321         }
 322         cal_client_handle_set_version(handle, version);
 323
 324         CAL_LIMIT_ACCESS_BACK;
 325         return ret;
 326 }
 327
 328 int cal_dbus_delete_record(calendar_h handle, const char *view_uri, int id)
 329 {
 330         GError *error = NULL;
 331         int ret = 0;
 332         int version = 0;
 333
 334         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 335         RETV_IF(NULL == view_uri, CALENDAR_ERROR_INVALID_PARAMETER);
 336         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 337
 338         CAL_LIMIT_ACCESS_FRONT(view_uri);
 339
 340         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 341         cal_dbus_call_delete_record_sync(cal_dbus_object, arg_handle, view_uri, id,
 342                         &version, &ret, NULL, &error);
 343         g_variant_unref(arg_handle);
 344         if (error) {
 345                 ERR("cal_dbus_call_delete_record_sync() Fail[%s]", error->message);
 346                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 347                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 348                 else
 349                         ret = CALENDAR_ERROR_IPC;
 350                 g_error_free(error);
 351                 return ret;
 352         }
 353         cal_client_handle_set_version(handle, version);
 354
 355         CAL_LIMIT_ACCESS_BACK;
 356         return ret;
 357 }
 358
 359 int cal_dbus_replace_record(calendar_h handle, calendar_record_h record, int id)
 360 {
 361         GError *error = NULL;
 362         int ret = 0;
 363         int version = 0;
 364
 365         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 366         RETV_IF(NULL == record, CALENDAR_ERROR_INVALID_PARAMETER);
 367         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 368
 369         CAL_LIMIT_ACCESS_FRONT(((cal_record_s *)record)->view_uri);
 370
 371         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 372         GVariant *arg_record = cal_dbus_utils_record_to_gvariant(record);
 373         cal_dbus_call_replace_record_sync(cal_dbus_object, arg_handle, arg_record, id,
 374                         &version, &ret, NULL, &error);
 375         g_variant_unref(arg_record);
 376         g_variant_unref(arg_handle);
 377         if (error) {
 378                 ERR("cal_dbus_call_replace_record_sync() Fail[%s]", error->message);
 379                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 380                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 381                 else
 382                         ret = CALENDAR_ERROR_IPC;
 383                 g_error_free(error);
 384                 return ret;
 385         }
 386         cal_client_handle_set_version(handle, version);
 387
 388         CAL_LIMIT_ACCESS_BACK;
 389         return ret;
 390 }
 391
 392 int cal_dbus_insert_records(calendar_h handle, calendar_list_h list,
 393                 int** out_ids, int* out_count)
 394 {
 395         GError *error = NULL;
 396         int ret = 0;
 397         int count = 0;
 398         int version = 0;
 399
 400         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 401         RETV_IF(NULL == list, CALENDAR_ERROR_INVALID_PARAMETER);
 402         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 403
 404         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 405         GVariant *arg_list = cal_dbus_utils_list_to_gvariant(list);
 406         GVariant *arg_ids = NULL;
 407         cal_dbus_call_insert_records_sync(cal_dbus_object, arg_handle, arg_list,
 408                         &arg_ids, &count, &version, &ret, NULL, &error);
 409         g_variant_unref(arg_list);
 410         g_variant_unref(arg_handle);
 411         if (error) {
 412                 ERR("cal_dbus_call_insert_records_sync() Fail[%s]", error->message);
 413                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 414                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 415                 else
 416                         ret = CALENDAR_ERROR_IPC;
 417                 g_error_free(error);
 418                 return ret;
 419         }
 420
 421         cal_client_handle_set_version(handle, version);
 422
 423         int *ids = NULL;
 424         cal_dbus_utils_gvariant_to_ids(arg_ids, count, &ids);
 425         g_variant_unref(arg_ids);
 426
 427         if (out_ids)
 428                 *out_ids = ids;
 429         else
 430                 free(ids);
 431
 432         if (out_count)
 433                 *out_count = count;
 434
 435         return ret;
 436 }
 437
 438 int cal_dbus_update_records(calendar_h handle, calendar_list_h list)
 439 {
 440         GError *error = NULL;
 441         int ret = 0;
 442         int version = 0;
 443
 444         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 445         RETV_IF(NULL == list, CALENDAR_ERROR_INVALID_PARAMETER);
 446         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 447
 448         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 449         GVariant *arg_list = cal_dbus_utils_list_to_gvariant(list);
 450         cal_dbus_call_update_records_sync(cal_dbus_object, arg_handle, arg_list,
 451                         &version, &ret, NULL, &error);
 452         g_variant_unref(arg_list);
 453         g_variant_unref(arg_handle);
 454         if (error) {
 455                 ERR("cal_dbus_call_update_records_sync() Fail[%s]",  error->message);
 456                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 457                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 458                 else
 459                         ret = CALENDAR_ERROR_IPC;
 460                 g_error_free(error);
 461                 return ret;
 462         }
 463         cal_client_handle_set_version(handle, version);
 464
 465         return ret;
 466 }
 467
 468 int cal_dbus_delete_records(calendar_h handle, const char *view_uri, int *ids, int count)
 469 {
 470         GError *error = NULL;
 471         int ret = 0;
 472         int version = 0;
 473
 474         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 475         RETV_IF(NULL == view_uri, CALENDAR_ERROR_INVALID_PARAMETER);
 476         RETV_IF(NULL == ids, CALENDAR_ERROR_INVALID_PARAMETER);
 477         RETV_IF(0 == count, CALENDAR_ERROR_INVALID_PARAMETER);
 478         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 479
 480         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 481         GVariant *arg_ids = cal_dbus_utils_ids_to_gvariant(ids, count);
 482         cal_dbus_call_delete_records_sync(cal_dbus_object, arg_handle, view_uri,
 483                         arg_ids, count, &version, &ret, NULL, &error);
 484         g_variant_unref(arg_ids);
 485         g_variant_unref(arg_handle);
 486         if (error) {
 487                 ERR("cal_dbus_call_delete_records_sync() Fail[%s]",  error->message);
 488                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 489                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 490                 else
 491                         ret = CALENDAR_ERROR_IPC;
 492                 g_error_free(error);
 493                 return ret;
 494         }
 495         cal_client_handle_set_version(handle, version);
 496
 497         return ret;
 498 }
 499
 500 int cal_dbus_replace_records(calendar_h handle, calendar_list_h list, int *ids, int count)
 501 {
 502         GError *error = NULL;
 503         int ret = 0;
 504         int version = 0;
 505
 506         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 507         RETV_IF(NULL == list, CALENDAR_ERROR_INVALID_PARAMETER);
 508         RETV_IF(NULL == ids, CALENDAR_ERROR_INVALID_PARAMETER);
 509         RETV_IF(0 == count, CALENDAR_ERROR_INVALID_PARAMETER);
 510         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 511
 512         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 513         GVariant *arg_list = cal_dbus_utils_list_to_gvariant(list);
 514         GVariant *arg_ids = cal_dbus_utils_ids_to_gvariant(ids, count);
 515         cal_dbus_call_replace_records_sync(cal_dbus_object, arg_handle, arg_list,
 516                         arg_ids, count, &version, &ret, NULL, &error);
 517         g_variant_unref(arg_list);
 518         g_variant_unref(arg_ids);
 519         g_variant_unref(arg_handle);
 520         if (error) {
 521                 ERR("cal_dbus_call_replace_records_sync() Fail[%s]",  error->message);
 522                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 523                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 524                 else
 525                         ret = CALENDAR_ERROR_IPC;
 526                 g_error_free(error);
 527                 return ret;
 528         }
 529         cal_client_handle_set_version(handle, version);
 530
 531         return ret;
 532 }
 533
 534 int cal_dbus_get_record(calendar_h handle, const char *view_uri, int id,
 535                 calendar_record_h *out_record)
 536 {
 537         GError *error = NULL;
 538         int ret = 0;
 539
 540         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 541         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
 542         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 543
 544         DBG("uri[%s]", view_uri);
 545         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 546         GVariant *arg_record = NULL;
 547         cal_dbus_call_get_record_sync(cal_dbus_object, arg_handle, view_uri, id,
 548                         &arg_record, &ret, NULL, &error);
 549         g_variant_unref(arg_handle);
 550         if (error) {
 551                 ERR("cal_dbus_call_get_record_sync() Fail[%s]",  error->message);
 552                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 553                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 554                 else
 555                         ret = CALENDAR_ERROR_IPC;
 556                 g_error_free(error);
 557                 return ret;
 558         }
 559
 560         if (CALENDAR_ERROR_NONE != ret) {
 561                 ERR("get_record() Fail(%d)", ret);
 562                 g_variant_unref(arg_record);
 563                 *out_record = NULL;
 564                 return ret;
 565         }
 566         cal_dbus_utils_gvariant_to_record(arg_record, out_record);
 567         g_variant_unref(arg_record);
 568
 569         return ret;
 570 }
 571
 572 int cal_dbus_get_all_records(calendar_h handle, const char *view_uri,
 573                 int offset, int limit, calendar_list_h *out_list)
 574 {
 575         GError *error = NULL;
 576         int ret = 0;
 577
 578         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 579         RETV_IF(NULL == out_list, CALENDAR_ERROR_INVALID_PARAMETER);
 580         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 581
 582         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 583         GVariant *arg_list = NULL;
 584         cal_dbus_call_get_all_records_sync(cal_dbus_object, arg_handle, view_uri,
 585                         offset, limit, &arg_list, &ret, NULL, &error);
 586         g_variant_unref(arg_handle);
 587         if (error) {
 588                 ERR("cal_dbus_call_get_all_records_sync() Fail[%s]", error->message);
 589                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 590                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 591                 else
 592                         ret = CALENDAR_ERROR_IPC;
 593                 g_error_free(error);
 594                 return ret;
 595         }
 596
 597         if (CALENDAR_ERROR_NONE != ret) {
 598                 ERR("get_all_records() Fail(%d)", ret);
 599                 g_variant_unref(arg_list);
 600                 *out_list = NULL;
 601                 return ret;
 602         }
 603
 604         cal_dbus_utils_gvariant_to_list(arg_list, out_list);
 605         g_variant_unref(arg_list);
 606
 607         if (*out_list)
 608                 calendar_list_first(*out_list);
 609
 610         return ret;
 611 }
 612
 613 int cal_dbus_get_records_with_query(calendar_h handle, calendar_query_h query,
 614                 int offset, int limit, calendar_list_h* out_list)
 615 {
 616         GError *error = NULL;
 617         int ret = 0;
 618
 619         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 620         RETV_IF(NULL == out_list, CALENDAR_ERROR_INVALID_PARAMETER);
 621         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 622
 623         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 624         GVariant *arg_query = cal_dbus_utils_query_to_gvariant(query);
 625         GVariant *arg_list = NULL;
 626         cal_dbus_call_get_records_with_query_sync(cal_dbus_object, arg_handle, arg_query,
 627                         offset, limit, &arg_list, &ret, NULL, &error);
 628         g_variant_unref(arg_query);
 629         g_variant_unref(arg_handle);
 630         if (error) {
 631                 ERR("cal_dbus_call_get_records_with_query_sync() Fail[%s]",  error->message);
 632                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 633                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 634                 else
 635                         ret = CALENDAR_ERROR_IPC;
 636                 g_error_free(error);
 637                 return ret;
 638         }
 639         cal_dbus_utils_gvariant_to_list(arg_list, out_list);
 640         g_variant_unref(arg_list);
 641
 642         if (*out_list)
 643                 calendar_list_first(*out_list);
 644
 645         return ret;
 646 }
 647
 648 int cal_dbus_get_count(calendar_h handle, const char *view_uri, int *out_count)
 649 {
 650         GError *error = NULL;
 651         int ret = 0;
 652         int count = 0;
 653
 654         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 655         RETV_IF(NULL == out_count, CALENDAR_ERROR_INVALID_PARAMETER);
 656         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 657
 658         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 659         cal_dbus_call_get_count_sync(cal_dbus_object, arg_handle, view_uri,
 660                         &count, &ret, NULL, &error);
 661         g_variant_unref(arg_handle);
 662         if (error) {
 663                 ERR("cal_dbus_call_get_count_sync() Fail[%s]",  error->message);
 664                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 665                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 666                 else
 667                         ret = CALENDAR_ERROR_IPC;
 668                 g_error_free(error);
 669                 return ret;
 670         }
 671         *out_count = count;
 672
 673         return ret;
 674 }
 675
 676 int cal_dbus_get_count_with_query(calendar_h handle, calendar_query_h query, int *out_count)
 677 {
 678         GError *error = NULL;
 679         int ret = 0;
 680         int count = 0;
 681
 682         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 683         RETV_IF(NULL == out_count, CALENDAR_ERROR_INVALID_PARAMETER);
 684         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 685
 686         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 687         GVariant *arg_query = cal_dbus_utils_query_to_gvariant(query);
 688         cal_dbus_call_get_count_with_query_sync(cal_dbus_object, arg_handle, arg_query,
 689                         &count, &ret, NULL, &error);
 690         g_variant_unref(arg_query);
 691         g_variant_unref(arg_handle);
 692         if (error) {
 693                 ERR("cal_dbus_call_get_count_with_query_sync() Fail[%s]",  error->message);
 694                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 695                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 696                 else
 697                         ret = CALENDAR_ERROR_IPC;
 698                 g_error_free(error);
 699                 return ret;
 700         }
 701         *out_count = count;
 702
 703         return ret;
 704 }
 705
 706 int cal_dbus_add_changed_cb(calendar_h handle, const char* view_uri,
 707                 void *callback, void* user_data)
 708 {
 709         GError *error = NULL;
 710         int ret = 0;
 711
 712         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 713         RETV_IF(NULL == callback, CALENDAR_ERROR_INVALID_PARAMETER);
 714
 715         cal_dbus_call_check_permission_write_sync(cal_dbus_object, NULL, &error);
 716         if (error) {
 717                 ERR("cal_dbus_call_check_permission_write_sync() Fail[%s]", error->message);
 718                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 719                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 720                 else
 721                         ret = CALENDAR_ERROR_IPC;
 722                 g_error_free(error);
 723                 return ret;
 724         }
 725
 726         return cal_client_db_add_changed_cb(handle, view_uri, callback, user_data);
 727 }
 728
 729 int cal_dbus_remove_changed_cb(calendar_h handle, const char* view_uri,
 730                 void *callback, void* user_data)
 731 {
 732         GError *error = NULL;
 733         int ret = 0;
 734
 735         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 736         RETV_IF(NULL == callback, CALENDAR_ERROR_INVALID_PARAMETER);
 737
 738         cal_dbus_call_check_permission_write_sync(cal_dbus_object, NULL, &error);
 739         if (error) {
 740                 ERR("cal_dbus_call_check_permission_write_sync() Fail[%s]", error->message);
 741                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 742                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 743                 else
 744                         ret = CALENDAR_ERROR_IPC;
 745                 g_error_free(error);
 746                 return ret;
 747         }
 748         return cal_client_db_remove_changed_cb(handle, view_uri, callback, user_data);
 749 }
 750
 751 int cal_dbus_get_current_version(calendar_h handle, int *out_version)
 752 {
 753         GError *error = NULL;
 754         int ret = 0;
 755         int version = 0;
 756
 757         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 758         RETV_IF(NULL == out_version, CALENDAR_ERROR_INVALID_PARAMETER);
 759         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 760
 761         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 762         cal_dbus_call_get_current_version_sync(cal_dbus_object, arg_handle,
 763                         &version, &ret, NULL, &error);
 764         g_variant_unref(arg_handle);
 765         if (error) {
 766                 ERR("cal_dbus_call_get_current_version_sync() Fail[%s]",  error->message);
 767                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 768                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 769                 else
 770                         ret = CALENDAR_ERROR_IPC;
 771                 g_error_free(error);
 772                 return ret;
 773         }
 774         if (CALENDAR_ERROR_NONE != ret) {
 775                 ERR("server return Fail(%d)", ret);
 776                 return ret;
 777         }
 778         *out_version = version;
 779
 780         return ret;
 781 }
 782
 783 int cal_dbus_get_last_change_version(calendar_h handle, int *out_version)
 784 {
 785         GError *error = NULL;
 786         int ret = 0;
 787
 788         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 789         RETV_IF(NULL == out_version, CALENDAR_ERROR_INVALID_PARAMETER);
 790
 791         cal_dbus_call_check_permission_read_sync(cal_dbus_object, NULL, &error);
 792         if (error) {
 793                 ERR("cal_dbus_call_check_permission_read_sync() Fail[%s]", error->message);
 794                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 795                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 796                 else
 797                         ret = CALENDAR_ERROR_IPC;
 798                 g_error_free(error);
 799                 return ret;
 800         }
 801         return cal_handle_get_version(handle, out_version);
 802 }
 803
 804 int cal_dbus_get_changes_by_version(calendar_h handle, const char *view_uri,
 805                 int book_id, int in_version, calendar_list_h *out_list, int *out_version)
 806 {
 807         GError *error = NULL;
 808         int ret = 0;
 809
 810         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 811         RETV_IF(NULL == view_uri, CALENDAR_ERROR_INVALID_PARAMETER);
 812         RETV_IF(NULL == out_list, CALENDAR_ERROR_INVALID_PARAMETER);
 813         RETV_IF(NULL == out_version, CALENDAR_ERROR_INVALID_PARAMETER);
 814         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 815
 816         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 817         GVariant *arg_list = NULL;
 818         cal_dbus_call_get_changes_by_version_sync(cal_dbus_object, arg_handle, view_uri,
 819                         book_id, in_version, &arg_list, out_version, &ret, NULL, &error);
 820         g_variant_unref(arg_handle);
 821         if (error) {
 822                 ERR("cal_dbus_call_get_changes_by_version_sync() Fail[%s]",  error->message);
 823                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 824                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 825                 else
 826                         ret = CALENDAR_ERROR_IPC;
 827                 g_error_free(error);
 828                 return ret;
 829         }
 830         cal_dbus_utils_gvariant_to_list(arg_list, out_list);
 831         g_variant_unref(arg_list);
 832
 833         if (*out_list)
 834                 calendar_list_first(*out_list);
 835
 836         return ret;
 837 }
 838
 839 int cal_dbus_get_changes_exception_by_version(calendar_h handle, const char *view_uri,
 840                 int original_id, int version, calendar_list_h *out_list)
 841 {
 842         GError *error = NULL;
 843         int ret = 0;
 844
 845         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 846         RETV_IF(NULL == view_uri, CALENDAR_ERROR_INVALID_PARAMETER);
 847         RETV_IF(NULL == out_list, CALENDAR_ERROR_INVALID_PARAMETER);
 848         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 849
 850         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 851         GVariant *arg_list = NULL;
 852         cal_dbus_call_get_changes_exception_by_version_sync(cal_dbus_object, arg_handle,
 853                         view_uri, original_id, version, &arg_list, &ret, NULL, &error);
 854         g_variant_unref(arg_handle);
 855         if (error) {
 856                 ERR("cal_dbus_call_get_changes_exception_by_version_sync() Fail[%s]",  error->message);
 857                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 858                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 859                 else
 860                         ret = CALENDAR_ERROR_IPC;
 861                 g_error_free(error);
 862                 return ret;
 863         }
 864         cal_client_handle_set_version(handle, version);
 865
 866         cal_dbus_utils_gvariant_to_list(arg_list, out_list);
 867         g_variant_unref(arg_list);
 868
 869         if (*out_list)
 870                 calendar_list_first(*out_list);
 871
 872         return ret;
 873 }
 874
 875 int cal_dbus_clean_after_sync(calendar_h handle, int book_id, int version)
 876 {
 877         GError *error = NULL;
 878         int ret = 0;
 879
 880         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 881         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 882
 883         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 884         cal_dbus_call_clean_after_sync_sync(cal_dbus_object, arg_handle, book_id, version,
 885                         &ret, NULL, &error);
 886         g_variant_unref(arg_handle);
 887         if (error) {
 888                 ERR("cal_dbus_call_clean_after_sync_sync() Fail[%s]",  error->message);
 889                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 890                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 891                 else
 892                         ret = CALENDAR_ERROR_IPC;
 893                 g_error_free(error);
 894                 return ret;
 895         }
 896
 897         return ret;
 898 }
 899
 900 int cal_dbus_insert_vcalendars(calendar_h handle, const char *stream,
 901                 int **out_ids, int *out_count)
 902 {
 903         GError *error = NULL;
 904         int ret = 0;
 905         int version = 0;
 906         int count = 0;
 907         GVariant *arg_ids = NULL;
 908
 909         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 910         RETV_IF(NULL == stream, CALENDAR_ERROR_INVALID_PARAMETER);
 911         RETV_IF(NULL == out_count, CALENDAR_ERROR_INVALID_PARAMETER);
 912         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 913
 914         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 915         cal_dbus_call_insert_vcalendars_sync(cal_dbus_object, arg_handle, stream,
 916                         &arg_ids, &count, &version, &ret, NULL, &error);
 917         g_variant_unref(arg_handle);
 918         if (error) {
 919                 ERR("cal_dbus_call_insert_vcalendars_sync() Fail[%s]",  error->message);
 920                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 921                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 922                 else
 923                         ret = CALENDAR_ERROR_IPC;
 924                 g_error_free(error);
 925                 return ret;
 926         }
 927         cal_client_handle_set_version(handle, version);
 928
 929         int *ids = NULL;
 930         cal_dbus_utils_gvariant_to_ids(arg_ids, count, &ids);
 931         g_variant_unref(arg_ids);
 932
 933         if (out_ids)
 934                 *out_ids = ids;
 935         else
 936                 free(ids);
 937
 938         if (out_count)
 939                 *out_count = count;
 940
 941         return ret;
 942 }
 943
 944 int cal_dbus_replace_vcalendars(calendar_h handle, const char *stream,
 945                 int *ids, int count)
 946 {
 947         GError *error = NULL;
 948         int ret = 0;
 949         int version = 0;
 950
 951         RETV_IF(NULL == handle, CALENDAR_ERROR_INVALID_PARAMETER);
 952         RETV_IF(NULL == stream, CALENDAR_ERROR_INVALID_PARAMETER);
 953         RETV_IF(NULL == ids, CALENDAR_ERROR_INVALID_PARAMETER);
 954         RETV_IF(0 == count, CALENDAR_ERROR_INVALID_PARAMETER);
 955         RETV_IF(NULL == cal_dbus_object, CALENDAR_ERROR_IPC);
 956
 957         GVariant *arg_handle = cal_dbus_utils_handle_to_gvariant(handle);
 958         GVariant *arg_ids = cal_dbus_utils_ids_to_gvariant(ids, count);
 959         cal_dbus_call_replace_vcalendars_sync(cal_dbus_object, arg_handle, stream,
 960                         arg_ids, count, &ret, &version, NULL, &error);
 961         g_variant_unref(arg_ids);
 962         g_variant_unref(arg_handle);
 963         if (error) {
 964                 ERR("cal_dbus_call_replace_vcalendars_sync Fail[%s]",  error->message);
 965                 if (G_DBUS_ERROR_ACCESS_DENIED == error->code)
 966                         ret = CALENDAR_ERROR_PERMISSION_DENIED;
 967                 else
 968                         ret = CALENDAR_ERROR_IPC;
 969                 g_error_free(error);
 970                 return ret;
 971         }
 972         cal_client_handle_set_version(handle, version);
 973
 974         return ret;
 975 }
 976