client/cal_client_db.c

   1 /*
   2  * Calendar Service
   3  *
   4  * Copyright (c) 2012 - 2013 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 <stdlib.h>     //calloc
  21 #include <pims-ipc.h>
  22 #include <glib-object.h>    //g_type_init
  23
  24 #include "calendar_service.h"
  25 #include "calendar_db.h"
  26 #include "calendar_types2.h"
  27
  28 #include "cal_internal.h"
  29 #include "cal_typedef.h"
  30 #include "cal_inotify.h"
  31 #include "cal_view.h"
  32 #include "cal_record.h"
  33 #include "cal_list.h"
  34 #include "cal_mutex.h"
  35
  36 #include "cal_ipc.h"
  37 #include "cal_ipc_marshal.h"
  38
  39 #include "cal_client_ipc.h"
  40
  41 typedef struct {
  42     calendar_db_result_cb callback;
  43     void *user_data;
  44 }cal_client_db_async_userdata_s;
  45
  46 typedef struct {
  47     calendar_db_insert_result_cb callback;
  48     void *user_data;
  49 }cal_client_db_async_insert_userdata_s;
  50
  51 #define CAL_IPC_DATA_FREE(ptr) \
  52     do { \
  53         if (ptr) \
  54         pims_ipc_data_destroy(ptr); \
  55         ptr = NULL; \
  56     } while(0)
  57
  58
  59 void __cal_client_db_insert_records_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata);
  60 void __cal_client_db_update_records_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata);
  61 void __cal_client_db_delete_records_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata);
  62 void __cal_client_db_insert_vcalendars_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata);
  63 void __cal_client_db_replace_vcalendars_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata);
  64 void __cal_client_db_replace_records_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata);
  65
  66 void __cal_client_db_insert_records_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata)
  67 {
  68     cal_client_db_async_insert_userdata_s *sync_data = (cal_client_db_async_insert_userdata_s *)userdata;
  69     int ret = CALENDAR_ERROR_NONE;
  70
  71     int count = 0;
  72     int *id = 0;
  73
  74     if (sync_data == NULL)
  75     {
  76         ERR("sync_data is NULL");
  77         return;
  78     }
  79
  80     if (data_out)
  81     {
  82         // check outdata
  83         unsigned int size = 0;
  84         ret = *(int*) pims_ipc_data_get(data_out,&size);
  85
  86         if (ret == CALENDAR_ERROR_NONE )
  87         {
  88             int i=0;
  89             unsigned int size = 0;
  90
  91             int transaction_ver = 0;
  92             transaction_ver = *(int*)pims_ipc_data_get(data_out,&size);
  93             _cal_client_ipc_set_change_version(transaction_ver);
  94
  95             count = *(int*) pims_ipc_data_get(data_out,&size);
  96
  97             id = calloc(1, sizeof(int)*count);
  98
  99             if (id)
 100             {
 101                 for(i=0;i<count;i++)
 102                 {
 103                     id[i] = *(unsigned int*) pims_ipc_data_get(data_out,&size);
 104                 }
 105             }
 106             else
 107             {
 108                 count = 0;
 109             }
 110         }
 111
 112     }
 113     else
 114     {
 115         ret = CALENDAR_ERROR_IPC;
 116         ERR("async cb is no data");
 117     }
 118
 119     if (sync_data->callback)
 120     {
 121         sync_data->callback(ret, id, count, sync_data->user_data);
 122     }
 123
 124         _cal_inotify_call_pending_callback();
 125
 126     CAL_FREE(id);
 127
 128     CAL_FREE(sync_data);
 129
 130     return ;
 131 }
 132
 133 void __cal_client_db_update_records_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata)
 134 {
 135     cal_client_db_async_userdata_s *sync_data = (cal_client_db_async_userdata_s *)userdata;
 136     int ret = CALENDAR_ERROR_NONE;
 137
 138     if (sync_data == NULL)
 139     {
 140         ERR("sync_data is NULL");
 141         return;
 142     }
 143
 144     if (data_out)
 145     {
 146         // check outdata
 147         unsigned int size = 0;
 148         ret = *(int*) pims_ipc_data_get(data_out,&size);
 149
 150         if (ret == CALENDAR_ERROR_NONE)
 151         {
 152             int transaction_ver = 0;
 153             transaction_ver = *(int*)pims_ipc_data_get(data_out,&size);
 154             _cal_client_ipc_set_change_version(transaction_ver);
 155         }
 156     }
 157     else
 158     {
 159         ret = CALENDAR_ERROR_IPC;
 160         ERR("async cb is no data");
 161     }
 162
 163     if (sync_data->callback)
 164     {
 165         sync_data->callback(ret, sync_data->user_data);
 166     }
 167
 168         _cal_inotify_call_pending_callback();
 169
 170     CAL_FREE(sync_data);
 171
 172     return ;
 173 }
 174 void __cal_client_db_delete_records_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata)
 175 {
 176     cal_client_db_async_userdata_s *sync_data = (cal_client_db_async_userdata_s *)userdata;
 177     int ret = CALENDAR_ERROR_NONE;
 178
 179     if (sync_data == NULL)
 180     {
 181         ERR("sync_data is NULL");
 182         return;
 183     }
 184
 185     if (data_out)
 186     {
 187         // check outdata
 188         unsigned int size = 0;
 189         ret = *(int*) pims_ipc_data_get(data_out,&size);
 190
 191         if (ret == CALENDAR_ERROR_NONE)
 192         {
 193             int transaction_ver = 0;
 194             transaction_ver = *(int*)pims_ipc_data_get(data_out,&size);
 195             _cal_client_ipc_set_change_version(transaction_ver);
 196         }
 197     }
 198     else
 199     {
 200         ret = CALENDAR_ERROR_IPC;
 201         ERR("async cb is no data");
 202     }
 203
 204     if (sync_data->callback)
 205     {
 206         sync_data->callback(ret, sync_data->user_data);
 207     }
 208
 209         _cal_inotify_call_pending_callback();
 210
 211     CAL_FREE(sync_data);
 212
 213     return ;
 214 }
 215
 216 void __cal_client_db_insert_vcalendars_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata)
 217 {
 218     cal_client_db_async_insert_userdata_s *sync_data = (cal_client_db_async_insert_userdata_s *)userdata;
 219     int ret = CALENDAR_ERROR_NONE;
 220
 221     int count = 0;
 222     int *id = 0;
 223
 224     if (sync_data == NULL)
 225     {
 226         ERR("sync_data is NULL");
 227         return;
 228     }
 229
 230     if (data_out)
 231     {
 232         // check outdata
 233         unsigned int size = 0;
 234         ret = *(int*) pims_ipc_data_get(data_out,&size);
 235
 236         if (ret == CALENDAR_ERROR_NONE )
 237         {
 238             int i=0;
 239             unsigned int size = 0;
 240
 241             int transaction_ver = 0;
 242             transaction_ver = *(int*)pims_ipc_data_get(data_out,&size);
 243             _cal_client_ipc_set_change_version(transaction_ver);
 244
 245             count = *(int*) pims_ipc_data_get(data_out,&size);
 246
 247             id = calloc(1, sizeof(int)*count);
 248
 249             if (id)
 250             {
 251                 for(i=0;i<count;i++)
 252                 {
 253                     id[i] = *(unsigned int*) pims_ipc_data_get(data_out,&size);
 254                 }
 255             }
 256             else
 257             {
 258                 count = 0;
 259             }
 260         }
 261     }
 262     else
 263     {
 264         ret = CALENDAR_ERROR_IPC;
 265         ERR("async cb is no data");
 266     }
 267
 268     if (sync_data->callback)
 269     {
 270         sync_data->callback(ret, id, count, sync_data->user_data);
 271     }
 272
 273     _cal_inotify_call_pending_callback();
 274
 275     CAL_FREE(id);
 276
 277     CAL_FREE(sync_data);
 278
 279     return ;
 280 }
 281
 282 void __cal_client_db_replace_vcalendars_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata)
 283 {
 284     cal_client_db_async_userdata_s *sync_data = (cal_client_db_async_userdata_s *)userdata;
 285     int ret = CALENDAR_ERROR_NONE;
 286
 287     if (sync_data == NULL)
 288     {
 289         ERR("sync_data is NULL");
 290         return;
 291     }
 292
 293     if (data_out)
 294     {
 295         // check outdata
 296         unsigned int size = 0;
 297         ret = *(int*) pims_ipc_data_get(data_out,&size);
 298
 299         if (ret == CALENDAR_ERROR_NONE)
 300         {
 301             int transaction_ver = 0;
 302             transaction_ver = *(int*)pims_ipc_data_get(data_out,&size);
 303             _cal_client_ipc_set_change_version(transaction_ver);
 304         }
 305     }
 306     else
 307     {
 308         ret = CALENDAR_ERROR_IPC;
 309         ERR("async cb is no data");
 310     }
 311
 312     if (sync_data->callback)
 313     {
 314         sync_data->callback(ret, sync_data->user_data);
 315     }
 316
 317     _cal_inotify_call_pending_callback();
 318
 319     CAL_FREE(sync_data);
 320
 321     return ;
 322 }
 323
 324 void __cal_client_db_replace_records_cb(pims_ipc_h ipc, pims_ipc_data_h data_out, void *userdata)
 325 {
 326     cal_client_db_async_userdata_s *sync_data = (cal_client_db_async_userdata_s *)userdata;
 327     int ret = CALENDAR_ERROR_NONE;
 328
 329     if (sync_data == NULL)
 330     {
 331         ERR("sync_data is NULL");
 332         return;
 333     }
 334
 335     if (data_out)
 336     {
 337         // check outdata
 338         unsigned int size = 0;
 339         ret = *(int*) pims_ipc_data_get(data_out,&size);
 340
 341         if (ret == CALENDAR_ERROR_NONE)
 342         {
 343             int transaction_ver = 0;
 344             transaction_ver = *(int*)pims_ipc_data_get(data_out,&size);
 345             _cal_client_ipc_set_change_version(transaction_ver);
 346         }
 347     }
 348     else
 349     {
 350         ret = CALENDAR_ERROR_IPC;
 351         ERR("async cb is no data");
 352     }
 353
 354     if (sync_data->callback)
 355     {
 356         sync_data->callback(ret, sync_data->user_data);
 357     }
 358
 359     _cal_inotify_call_pending_callback();
 360
 361     CAL_FREE(sync_data);
 362
 363     return ;
 364 }
 365
 366 API int calendar_db_insert_record( calendar_record_h record, int* id )
 367 {
 368     int ret = CALENDAR_ERROR_NONE;
 369     pims_ipc_data_h indata = NULL;
 370     pims_ipc_data_h outdata = NULL;
 371
 372     retvm_if(record==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record is NULL");
 373
 374     CAL_RECORD_RESET_COMMON((cal_record_s*)record);
 375     // make indata
 376     indata = pims_ipc_data_create(0);
 377     if (indata == NULL)
 378     {
 379         ERR("ipc data created fail !");
 380         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 381         return ret;
 382     }
 383     ret = _cal_ipc_marshal_record(record,indata);
 384     if (ret != CALENDAR_ERROR_NONE)
 385     {
 386         ERR("marshal fail");
 387         CAL_IPC_DATA_FREE(indata);
 388         return ret;
 389     }
 390
 391     // ipc call
 392     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_INSERT_RECORD, indata, &outdata) != 0)
 393     {
 394         ERR("pims_ipc_call failed");
 395         CAL_IPC_DATA_FREE(indata);
 396         return CALENDAR_ERROR_IPC;
 397     }
 398
 399     CAL_IPC_DATA_FREE(indata);
 400
 401     if (outdata)
 402     {
 403         //int id = 0;
 404         // check outdata
 405         unsigned int size = 0;
 406         ret = *(int*) pims_ipc_data_get(outdata,&size);
 407
 408         if (ret == CALENDAR_ERROR_NONE)
 409         {
 410             int transaction_ver = 0;
 411             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
 412             _cal_client_ipc_set_change_version(transaction_ver);
 413             //unsigned int property_id = 0;
 414             int out_id = 0;
 415             //property_id = *(unsigned int*)pims_ipc_data_get(outdata,&size);
 416             out_id = *(int*)pims_ipc_data_get(outdata,&size);
 417             //_cal_record_set_int(record,property_id,id);
 418             if (id)
 419             {
 420                 *id = out_id;
 421             }
 422         }
 423
 424         pims_ipc_data_destroy(outdata);
 425     }
 426     else
 427     {
 428         ERR("ipc outdata is NULL");
 429         return CALENDAR_ERROR_IPC;
 430     }
 431
 432     return ret;
 433 }
 434
 435 API int calendar_db_get_record( const char* view_uri, int id, calendar_record_h* out_record )
 436 {
 437     int ret = CALENDAR_ERROR_NONE;
 438     pims_ipc_data_h indata = NULL;
 439     pims_ipc_data_h outdata = NULL;
 440
 441     retvm_if(view_uri==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"view_uri is NULL");
 442     retvm_if(id<=0,CALENDAR_ERROR_INVALID_PARAMETER,"id <= 0");
 443     retvm_if(out_record==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record is NULL");
 444
 445     // make indata
 446     indata = pims_ipc_data_create(0);
 447     if (indata == NULL)
 448     {
 449         ERR("ipc data created fail !");
 450         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 451         return ret;
 452     }
 453     ret = _cal_ipc_marshal_char(view_uri,indata);
 454     if (ret != CALENDAR_ERROR_NONE)
 455     {
 456         ERR("marshal fail");
 457         CAL_IPC_DATA_FREE(indata);
 458         return ret;
 459     }
 460     ret = _cal_ipc_marshal_int(id,indata);
 461     if (ret != CALENDAR_ERROR_NONE)
 462     {
 463         ERR("marshal fail");
 464         CAL_IPC_DATA_FREE(indata);
 465         return ret;
 466     }
 467
 468     // ipc call
 469     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_RECORD, indata, &outdata) != 0)
 470     {
 471         ERR("pims_ipc_call failed");
 472         CAL_IPC_DATA_FREE(indata);
 473         return CALENDAR_ERROR_IPC;
 474     }
 475
 476     CAL_IPC_DATA_FREE(indata);
 477
 478     if (outdata)
 479     {
 480         // check outdata
 481         unsigned int size = 0;
 482         ret = *(int*) pims_ipc_data_get(outdata,&size);
 483
 484         if (ret == CALENDAR_ERROR_NONE)
 485         {
 486             ret = _cal_ipc_unmarshal_record(outdata,out_record);
 487         }
 488
 489         pims_ipc_data_destroy(outdata);
 490     }
 491     else
 492     {
 493         ERR("ipc outdata is NULL");
 494         return CALENDAR_ERROR_IPC;
 495     }
 496
 497     return ret;
 498 }
 499
 500 API int calendar_db_update_record( calendar_record_h record )
 501 {
 502     int ret = CALENDAR_ERROR_NONE;
 503     pims_ipc_data_h indata = NULL;
 504     pims_ipc_data_h outdata = NULL;
 505
 506     retvm_if(record==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record is NULL");
 507
 508     // make indata
 509     indata = pims_ipc_data_create(0);
 510     if (indata == NULL)
 511     {
 512         ERR("ipc data created fail !");
 513         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 514         return ret;
 515     }
 516     ret = _cal_ipc_marshal_record(record,indata);
 517     if (ret != CALENDAR_ERROR_NONE)
 518     {
 519         ERR("marshal fail");
 520         CAL_IPC_DATA_FREE(indata);
 521         return ret;
 522     }
 523
 524     // ipc call
 525     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_UPDATE_RECORD, indata, &outdata) != 0)
 526     {
 527         ERR("pims_ipc_call failed");
 528         CAL_IPC_DATA_FREE(indata);
 529         return CALENDAR_ERROR_IPC;
 530     }
 531
 532     CAL_IPC_DATA_FREE(indata);
 533
 534     if (outdata)
 535     {
 536         // check outdata
 537         unsigned int size = 0;
 538         ret = *(int*) pims_ipc_data_get(outdata,&size);
 539
 540         if (ret == CALENDAR_ERROR_NONE)
 541         {
 542             int transaction_ver = 0;
 543             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
 544             _cal_client_ipc_set_change_version(transaction_ver);
 545         }
 546
 547         pims_ipc_data_destroy(outdata);
 548     }
 549     else
 550     {
 551         ERR("ipc outdata is NULL");
 552         return CALENDAR_ERROR_IPC;
 553     }
 554
 555     return ret;
 556 }
 557
 558 API int calendar_db_delete_record( const char* view_uri, int id )
 559 {
 560     int ret = CALENDAR_ERROR_NONE;
 561     pims_ipc_data_h indata = NULL;
 562     pims_ipc_data_h outdata = NULL;
 563
 564     retvm_if(view_uri==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"view_uri is NULL");
 565     retvm_if(id<=0,CALENDAR_ERROR_INVALID_PARAMETER,"id <= 0");
 566
 567     // make indata
 568     indata = pims_ipc_data_create(0);
 569     if (indata == NULL)
 570     {
 571         ERR("ipc data created fail !");
 572         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 573         return ret;
 574     }
 575     ret = _cal_ipc_marshal_char(view_uri,indata);
 576     if (ret != CALENDAR_ERROR_NONE)
 577     {
 578         ERR("marshal fail");
 579         CAL_IPC_DATA_FREE(indata);
 580         return ret;
 581     }
 582     ret = _cal_ipc_marshal_int(id,indata);
 583     if (ret != CALENDAR_ERROR_NONE)
 584     {
 585         ERR("marshal fail");
 586         CAL_IPC_DATA_FREE(indata);
 587         return ret;
 588     }
 589
 590     // ipc call
 591     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_DELETE_RECORD, indata, &outdata) != 0)
 592     {
 593         ERR("pims_ipc_call failed");
 594         CAL_IPC_DATA_FREE(indata);
 595         return CALENDAR_ERROR_IPC;
 596     }
 597
 598     CAL_IPC_DATA_FREE(indata);
 599
 600     if (outdata)
 601     {
 602         // check outdata
 603         unsigned int size = 0;
 604         ret = *(int*) pims_ipc_data_get(outdata,&size);
 605
 606         if (ret == CALENDAR_ERROR_NONE)
 607         {
 608             int transaction_ver = 0;
 609             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
 610             _cal_client_ipc_set_change_version(transaction_ver);
 611         }
 612
 613         pims_ipc_data_destroy(outdata);
 614     }
 615     else
 616     {
 617         ERR("ipc outdata is NULL");
 618         return CALENDAR_ERROR_IPC;
 619     }
 620
 621     return ret;
 622 }
 623
 624 API int calendar_db_get_all_records( const char* view_uri, int offset, int limit, calendar_list_h* out_list )
 625 {
 626     int ret = CALENDAR_ERROR_NONE;
 627     pims_ipc_data_h indata = NULL;
 628     pims_ipc_data_h outdata = NULL;
 629
 630     retvm_if(out_list==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"list is NULL");
 631     retvm_if(view_uri==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"view_uri is NULL");
 632
 633     // make indata
 634     indata = pims_ipc_data_create(0);
 635     if (indata == NULL)
 636     {
 637         ERR("ipc data created fail !");
 638         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 639         return ret;
 640     }
 641
 642     ret = _cal_ipc_marshal_char(view_uri,indata);
 643     if (ret != CALENDAR_ERROR_NONE)
 644     {
 645         ERR("marshal fail");
 646         CAL_IPC_DATA_FREE(indata);
 647         return ret;
 648     }
 649     ret = _cal_ipc_marshal_int(offset,indata);
 650     if (ret != CALENDAR_ERROR_NONE)
 651     {
 652         ERR("marshal fail");
 653         CAL_IPC_DATA_FREE(indata);
 654         return ret;
 655     }
 656     ret = _cal_ipc_marshal_int(limit,indata);
 657     if (ret != CALENDAR_ERROR_NONE)
 658     {
 659         ERR("marshal fail");
 660         CAL_IPC_DATA_FREE(indata);
 661         return ret;
 662     }
 663
 664     // ipc call
 665     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_ALL_RECORDS, indata, &outdata) != 0)
 666     {
 667         ERR("pims_ipc_call failed");
 668         CAL_IPC_DATA_FREE(indata);
 669         return CALENDAR_ERROR_IPC;
 670     }
 671
 672     CAL_IPC_DATA_FREE(indata);
 673
 674     if (outdata)
 675     {
 676         // check outdata
 677         unsigned int size = 0;
 678         ret = *(int*) pims_ipc_data_get(outdata,&size);
 679
 680         if (ret == CALENDAR_ERROR_NONE)
 681         {
 682             ret = _cal_ipc_unmarshal_list(outdata,out_list);
 683         }
 684         pims_ipc_data_destroy(outdata);
 685     }
 686     else
 687     {
 688         ERR("ipc outdata is NULL");
 689         return CALENDAR_ERROR_IPC;
 690     }
 691
 692     return ret;
 693 }
 694
 695 API int calendar_db_get_records_with_query( calendar_query_h query, int offset, int limit, calendar_list_h* out_list )
 696 {
 697     int ret = CALENDAR_ERROR_NONE;
 698     pims_ipc_data_h indata = NULL;
 699     pims_ipc_data_h outdata = NULL;
 700
 701     retvm_if(query==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"query is NULL");
 702     retvm_if(out_list==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"list is NULL");
 703
 704     // make indata
 705     indata = pims_ipc_data_create(0);
 706     if (indata == NULL)
 707     {
 708         ERR("ipc data created fail !");
 709         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 710         return ret;
 711     }
 712     ret = _cal_ipc_marshal_query(query,indata);
 713     if (ret != CALENDAR_ERROR_NONE)
 714     {
 715         ERR("marshal fail");
 716         CAL_IPC_DATA_FREE(indata);
 717         return ret;
 718     }
 719     ret = _cal_ipc_marshal_int(offset,indata);
 720     if (ret != CALENDAR_ERROR_NONE)
 721     {
 722         ERR("marshal fail");
 723         CAL_IPC_DATA_FREE(indata);
 724         return ret;
 725     }
 726     ret = _cal_ipc_marshal_int(limit,indata);
 727     if (ret != CALENDAR_ERROR_NONE)
 728     {
 729         ERR("marshal fail");
 730         CAL_IPC_DATA_FREE(indata);
 731         return ret;
 732     }
 733
 734     // ipc call
 735     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_RECORDS_WITH_QUERY, indata, &outdata) != 0)
 736     {
 737         ERR("pims_ipc_call failed");
 738         CAL_IPC_DATA_FREE(indata);
 739         return CALENDAR_ERROR_IPC;
 740     }
 741
 742     CAL_IPC_DATA_FREE(indata);
 743
 744     if (outdata)
 745     {
 746         // check outdata
 747         unsigned int size = 0;
 748         ret = *(int*) pims_ipc_data_get(outdata,&size);
 749
 750         if (ret == CALENDAR_ERROR_NONE)
 751         {
 752             ret = _cal_ipc_unmarshal_list(outdata,out_list);
 753         }
 754
 755         pims_ipc_data_destroy(outdata);
 756     }
 757     else
 758     {
 759         ERR("ipc outdata is NULL");
 760         return CALENDAR_ERROR_IPC;
 761     }
 762
 763     return ret;
 764 }
 765
 766 API int calendar_db_clean_after_sync( int calendar_book_id, int calendar_db_version)
 767 {
 768     int ret = CALENDAR_ERROR_NONE;
 769     pims_ipc_data_h indata = NULL;
 770     pims_ipc_data_h outdata = NULL;
 771
 772     retvm_if(calendar_book_id <= 0,CALENDAR_ERROR_INVALID_PARAMETER,"calendar_book_id < 0");
 773
 774     // make indata
 775     indata = pims_ipc_data_create(0);
 776     if (indata == NULL)
 777     {
 778         ERR("ipc data created fail !");
 779         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 780         return ret;
 781     }
 782     ret = _cal_ipc_marshal_int(calendar_book_id,indata);
 783     if (ret != CALENDAR_ERROR_NONE)
 784     {
 785         ERR("marshal fail");
 786         CAL_IPC_DATA_FREE(indata);
 787         return ret;
 788     }
 789     ret = _cal_ipc_marshal_int(calendar_db_version,indata);
 790     if (ret != CALENDAR_ERROR_NONE)
 791     {
 792         ERR("marshal fail");
 793         CAL_IPC_DATA_FREE(indata);
 794         return ret;
 795     }
 796
 797     // ipc call
 798     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_CLEAN_AFTER_SYNC, indata, &outdata) != 0)
 799     {
 800         ERR("pims_ipc_call failed");
 801         CAL_IPC_DATA_FREE(indata);
 802         return CALENDAR_ERROR_IPC;
 803     }
 804
 805     CAL_IPC_DATA_FREE(indata);
 806
 807     if (outdata)
 808     {
 809         // check outdata
 810         unsigned int size = 0;
 811         ret = *(int*) pims_ipc_data_get(outdata,&size);
 812
 813         pims_ipc_data_destroy(outdata);
 814     }
 815     else
 816     {
 817         ERR("ipc outdata is NULL");
 818         return CALENDAR_ERROR_IPC;
 819     }
 820
 821     return ret;
 822 }
 823
 824 API int calendar_db_get_count( const char* view_uri, int *out_count )
 825 {
 826     int ret = CALENDAR_ERROR_NONE;
 827     pims_ipc_data_h indata = NULL;
 828     pims_ipc_data_h outdata = NULL;
 829
 830     retvm_if(view_uri==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"view_uri is NULL");
 831     retvm_if(out_count==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"count pointer is NULL");
 832
 833     // make indata
 834     indata = pims_ipc_data_create(0);
 835     if (indata == NULL)
 836     {
 837         ERR("ipc data created fail !");
 838         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 839         return ret;
 840     }
 841     ret = _cal_ipc_marshal_char(view_uri,indata);
 842     if (ret != CALENDAR_ERROR_NONE)
 843     {
 844         ERR("marshal fail");
 845         CAL_IPC_DATA_FREE(indata);
 846         return ret;
 847     }
 848
 849     // ipc call
 850     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_COUNT, indata, &outdata) != 0)
 851     {
 852         ERR("pims_ipc_call failed");
 853         CAL_IPC_DATA_FREE(indata);
 854         return CALENDAR_ERROR_IPC;
 855     }
 856
 857     CAL_IPC_DATA_FREE(indata);
 858
 859     if (outdata)
 860     {
 861         // check outdata
 862         unsigned int size = 0;
 863         ret = *(int*) pims_ipc_data_get(outdata,&size);
 864
 865         if (ret == CALENDAR_ERROR_NONE)
 866         {
 867             ret = _cal_ipc_unmarshal_int(outdata,out_count);
 868         }
 869
 870         pims_ipc_data_destroy(outdata);
 871     }
 872     else
 873     {
 874         ERR("ipc outdata is NULL");
 875         return CALENDAR_ERROR_IPC;
 876     }
 877
 878     return ret;
 879 }
 880
 881 API int calendar_db_get_count_with_query( calendar_query_h query, int *out_count )
 882 {
 883     int ret = CALENDAR_ERROR_NONE;
 884     pims_ipc_data_h indata = NULL;
 885     pims_ipc_data_h outdata = NULL;
 886
 887     retvm_if(query==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record is NULL");
 888
 889     // make indata
 890     indata = pims_ipc_data_create(0);
 891     if (indata == NULL)
 892     {
 893         ERR("ipc data created fail !");
 894         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 895         return ret;
 896     }
 897     ret = _cal_ipc_marshal_query(query,indata);
 898     if (ret != CALENDAR_ERROR_NONE)
 899     {
 900         ERR("marshal fail");
 901         CAL_IPC_DATA_FREE(indata);
 902         return ret;
 903     }
 904
 905     // ipc call
 906     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_COUNT_WITH_QUERY, indata, &outdata) != 0)
 907     {
 908         ERR("pims_ipc_call failed");
 909         CAL_IPC_DATA_FREE(indata);
 910         return CALENDAR_ERROR_IPC;
 911     }
 912
 913     CAL_IPC_DATA_FREE(indata);
 914
 915     if (outdata)
 916     {
 917         // check outdata
 918         unsigned int size = 0;
 919         ret = *(int*) pims_ipc_data_get(outdata,&size);
 920
 921         if (ret == CALENDAR_ERROR_NONE)
 922         {
 923             ret = _cal_ipc_unmarshal_int(outdata,out_count);
 924         }
 925
 926         pims_ipc_data_destroy(outdata);
 927     }
 928     else
 929     {
 930         ERR("ipc outdata is NULL");
 931         return CALENDAR_ERROR_IPC;
 932     }
 933
 934     return ret;
 935 }
 936
 937 API int calendar_db_insert_records( calendar_list_h record_list, int** record_id_array, int* count)
 938 {
 939     int ret = CALENDAR_ERROR_NONE;
 940     pims_ipc_data_h indata = NULL;
 941     pims_ipc_data_h outdata = NULL;
 942
 943     retvm_if(record_list==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"list is NULL");
 944
 945     // make indata
 946     indata = pims_ipc_data_create(0);
 947     if (indata == NULL)
 948     {
 949         ERR("ipc data created fail !");
 950         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
 951         return ret;
 952     }
 953     ret = _cal_ipc_marshal_list(record_list,indata);
 954     if (ret != CALENDAR_ERROR_NONE)
 955     {
 956         ERR("marshal fail");
 957         CAL_IPC_DATA_FREE(indata);
 958         return ret;
 959     }
 960
 961     if (_cal_client_ipc_call(CAL_IPC_MODULE,CAL_IPC_SERVER_DB_INSERT_RECORDS,
 962             indata,&outdata) != 0)
 963     {
 964         ERR("pims_ipc_call failed");
 965         CAL_IPC_DATA_FREE(indata);
 966         return CALENDAR_ERROR_IPC;
 967     }
 968
 969     CAL_IPC_DATA_FREE(indata);
 970     if (outdata)
 971     {
 972         // check outdata
 973         unsigned int size = 0;
 974         ret = *(int*) pims_ipc_data_get(outdata,&size);
 975
 976         if (ret == CALENDAR_ERROR_NONE)
 977         {
 978             int transaction_ver = 0;
 979             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
 980             _cal_client_ipc_set_change_version(transaction_ver);
 981             goto SET_DATA;
 982         }
 983
 984         pims_ipc_data_destroy(outdata);
 985     }
 986     else
 987     {
 988         ERR("ipc outdata is NULL");
 989         return CALENDAR_ERROR_IPC;
 990     }
 991
 992     return ret;
 993
 994 SET_DATA:
 995     if (outdata)
 996     {
 997         int i=0;
 998         unsigned int size = 0;
 999         int *ids = NULL;
1000
1001         if (count && record_id_array)
1002         {
1003             *count = *(int*) pims_ipc_data_get(outdata,&size);
1004
1005             if (*count <=0)
1006             {
1007                 ERR("count is %d",*count);
1008                 count = 0;
1009                 pims_ipc_data_destroy(outdata);
1010                 return CALENDAR_ERROR_INVALID_PARAMETER;
1011             }
1012             ids = calloc(1, sizeof(int)*(*count));
1013
1014             if(ids == NULL)
1015             {
1016                 count = 0;
1017                 ERR("calloc fail");
1018                 pims_ipc_data_destroy(outdata);
1019                 return CALENDAR_ERROR_OUT_OF_MEMORY;
1020             }
1021             for(i=0;i<(*count);i++)
1022             {
1023                 ids[i] = *(int*) pims_ipc_data_get(outdata,&size);
1024             }
1025             *record_id_array = ids;
1026         }
1027         pims_ipc_data_destroy(outdata);
1028     }
1029
1030     return ret;
1031 }
1032
1033 API int calendar_db_insert_records_async(calendar_list_h list, calendar_db_insert_result_cb callback, void *user_data)
1034 {
1035     int ret = CALENDAR_ERROR_NONE;
1036     pims_ipc_data_h indata = NULL;
1037     cal_client_db_async_insert_userdata_s *async_data = NULL;
1038     calendar_list_h clone_list = NULL;
1039
1040     retvm_if(list==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"list is NULL");
1041     retvm_if(callback==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"list is NULL");
1042
1043     ret = _cal_list_clone(list, &clone_list);
1044         if (CALENDAR_ERROR_NONE != ret)
1045         {
1046                 ERR("_cal_list_clone() failed");
1047                 return ret;
1048         }
1049
1050     // make indata
1051     indata = pims_ipc_data_create(0);
1052     if (indata == NULL)
1053     {
1054         ERR("ipc data created fail !");
1055         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1056         calendar_list_destroy(clone_list, true);
1057         return ret;
1058     }
1059     ret = _cal_ipc_marshal_list(clone_list,indata);
1060     if (ret != CALENDAR_ERROR_NONE)
1061     {
1062         ERR("marshal fail");
1063         CAL_IPC_DATA_FREE(indata);
1064         calendar_list_destroy(clone_list, true);
1065         return ret;
1066     }
1067
1068     async_data = (cal_client_db_async_insert_userdata_s*)malloc(sizeof(cal_client_db_async_insert_userdata_s));
1069     if (async_data == NULL)
1070     {
1071         ERR("malloc fail !");
1072         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1073         calendar_list_destroy(clone_list, true);
1074         CAL_IPC_DATA_FREE(indata);
1075         return ret;
1076     }
1077     async_data->callback = callback;
1078     async_data->user_data = user_data;
1079
1080     if (_cal_client_ipc_call_async(CAL_IPC_MODULE,CAL_IPC_SERVER_DB_INSERT_RECORDS,
1081             indata,__cal_client_db_insert_records_cb,async_data) != 0)
1082     {
1083         ERR("pims_ipc_call_async failed");
1084         calendar_list_destroy(clone_list, true);
1085         CAL_IPC_DATA_FREE(indata);
1086         return CALENDAR_ERROR_IPC;
1087     }
1088
1089     CAL_IPC_DATA_FREE(indata);
1090
1091     calendar_list_destroy(clone_list, true);
1092
1093     return ret;
1094 }
1095
1096 API int calendar_db_update_records( calendar_list_h record_list)
1097 {
1098     int ret = CALENDAR_ERROR_NONE;
1099     pims_ipc_data_h indata = NULL;
1100     pims_ipc_data_h outdata = NULL;
1101
1102     retvm_if(record_list==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record is NULL");
1103
1104     // make indata
1105     indata = pims_ipc_data_create(0);
1106     if (indata == NULL)
1107     {
1108         ERR("ipc data created fail !");
1109         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1110         return ret;
1111     }
1112     ret = _cal_ipc_marshal_list(record_list,indata);
1113     if (ret != CALENDAR_ERROR_NONE)
1114     {
1115         ERR("marshal fail");
1116         CAL_IPC_DATA_FREE(indata);
1117         return ret;
1118     }
1119
1120     // ipc call
1121     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_UPDATE_RECORDS, indata, &outdata) != 0)
1122     {
1123         ERR("pims_ipc_call failed");
1124         CAL_IPC_DATA_FREE(indata);
1125         return CALENDAR_ERROR_IPC;
1126     }
1127
1128     CAL_IPC_DATA_FREE(indata);
1129
1130     if (outdata)
1131     {
1132         // check outdata
1133         unsigned int size = 0;
1134         ret = *(int*) pims_ipc_data_get(outdata,&size);
1135
1136         if (ret == CALENDAR_ERROR_NONE)
1137         {
1138             int transaction_ver = 0;
1139             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
1140             _cal_client_ipc_set_change_version(transaction_ver);
1141         }
1142
1143         pims_ipc_data_destroy(outdata);
1144     }
1145     else
1146     {
1147         ERR("ipc outdata is NULL");
1148         return CALENDAR_ERROR_IPC;
1149     }
1150
1151     return ret;
1152
1153 }
1154
1155 API int calendar_db_update_records_async( calendar_list_h list, calendar_db_result_cb callback, void *user_data)
1156 {
1157     int ret = CALENDAR_ERROR_NONE;
1158     pims_ipc_data_h indata = NULL;
1159     cal_client_db_async_userdata_s *async_data = NULL;
1160     calendar_list_h clone_list = NULL;
1161
1162     retvm_if(list==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record is NULL");
1163     retvm_if(callback==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"callback is NULL");
1164
1165     ret = _cal_list_clone(list, &clone_list);
1166         if (CALENDAR_ERROR_NONE != ret)
1167         {
1168                 ERR("_cal_list_clone() failed");
1169                 return ret;
1170         }
1171
1172     // make indata
1173     indata = pims_ipc_data_create(0);
1174     if (indata == NULL)
1175     {
1176         ERR("ipc data created fail !");
1177         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1178         calendar_list_destroy(clone_list, true);
1179         return ret;
1180     }
1181     ret = _cal_ipc_marshal_list(clone_list,indata);
1182     if (ret != CALENDAR_ERROR_NONE)
1183     {
1184         ERR("marshal fail");
1185         calendar_list_destroy(clone_list, true);
1186         CAL_IPC_DATA_FREE(indata);
1187         return ret;
1188     }
1189
1190     async_data = (cal_client_db_async_userdata_s*)malloc(sizeof(cal_client_db_async_userdata_s));
1191     if (async_data == NULL)
1192     {
1193         ERR("malloc fail !");
1194         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1195         calendar_list_destroy(clone_list, true);
1196         CAL_IPC_DATA_FREE(indata);
1197         return ret;
1198     }
1199     async_data->callback = callback;
1200     async_data->user_data = user_data;
1201
1202     if (_cal_client_ipc_call_async(CAL_IPC_MODULE,CAL_IPC_SERVER_DB_UPDATE_RECORDS,
1203             indata,__cal_client_db_update_records_cb,async_data) != 0)
1204     {
1205         ERR("pims_ipc_call_async failed");
1206         calendar_list_destroy(clone_list, true);
1207         CAL_IPC_DATA_FREE(indata);
1208         return CALENDAR_ERROR_IPC;
1209     }
1210
1211     CAL_IPC_DATA_FREE(indata);
1212
1213     calendar_list_destroy(clone_list, true);
1214     return ret;
1215 }
1216
1217 API int calendar_db_delete_records(const char* view_uri, int record_id_array[], int count)
1218 {
1219     int ret = CALENDAR_ERROR_NONE;
1220     pims_ipc_data_h indata = NULL;
1221     pims_ipc_data_h outdata = NULL;
1222     int i = 0;
1223
1224     retvm_if(view_uri==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"view_uri is NULL");
1225     retvm_if(record_id_array==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record_id_array is NULL");
1226     retvm_if(count<=0,CALENDAR_ERROR_INVALID_PARAMETER,"count <= 0 ");
1227
1228     // make indata
1229     indata = pims_ipc_data_create(0);
1230     if (indata == NULL)
1231     {
1232         ERR("ipc data created fail !");
1233         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1234         return ret;
1235     }
1236     ret = _cal_ipc_marshal_char(view_uri,indata);
1237     if (ret != CALENDAR_ERROR_NONE)
1238     {
1239         ERR("marshal fail");
1240         CAL_IPC_DATA_FREE(indata);
1241         return ret;
1242     }
1243     ret = _cal_ipc_marshal_int(count,indata);
1244     if (ret != CALENDAR_ERROR_NONE)
1245     {
1246         ERR("marshal fail");
1247         CAL_IPC_DATA_FREE(indata);
1248         return ret;
1249     }
1250     for (i=0;i<count;i++)
1251     {
1252         ret = _cal_ipc_marshal_int(record_id_array[i],indata);
1253         if (ret != CALENDAR_ERROR_NONE)
1254         {
1255             ERR("marshal fail");
1256             CAL_IPC_DATA_FREE(indata);
1257             return ret;
1258         }
1259     }
1260
1261     // ipc call
1262     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_DELETE_RECORDS, indata, &outdata) != 0)
1263     {
1264         ERR("pims_ipc_call failed");
1265         CAL_IPC_DATA_FREE(indata);
1266         return CALENDAR_ERROR_IPC;
1267     }
1268
1269     CAL_IPC_DATA_FREE(indata);
1270
1271     if (outdata)
1272     {
1273         // check outdata
1274         unsigned int size = 0;
1275         ret = *(int*) pims_ipc_data_get(outdata,&size);
1276
1277         if (ret == CALENDAR_ERROR_NONE)
1278         {
1279             int transaction_ver = 0;
1280             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
1281             _cal_client_ipc_set_change_version(transaction_ver);
1282         }
1283
1284         pims_ipc_data_destroy(outdata);
1285     }
1286     else
1287     {
1288         ERR("ipc outdata is NULL");
1289         return CALENDAR_ERROR_IPC;
1290     }
1291
1292     return ret;
1293
1294 }
1295
1296 API int calendar_db_delete_records_async(const char* view_uri, int ids[], int count, calendar_db_result_cb callback, void *user_data)
1297 {
1298     int ret = CALENDAR_ERROR_NONE;
1299     pims_ipc_data_h indata = NULL;
1300     int i = 0;
1301     cal_client_db_async_userdata_s *async_data = NULL;
1302
1303     retvm_if(view_uri==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"view_uri is NULL");
1304     retvm_if(callback==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"callback is NULL");
1305
1306     // make indata
1307     indata = pims_ipc_data_create(0);
1308     if (indata == NULL)
1309     {
1310         ERR("ipc data created fail !");
1311         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1312         return ret;
1313     }
1314     ret = _cal_ipc_marshal_char(view_uri,indata);
1315     if (ret != CALENDAR_ERROR_NONE)
1316     {
1317         ERR("marshal fail");
1318         CAL_IPC_DATA_FREE(indata);
1319         return ret;
1320     }
1321     ret = _cal_ipc_marshal_int(count,indata);
1322     if (ret != CALENDAR_ERROR_NONE)
1323     {
1324         ERR("marshal fail");
1325         CAL_IPC_DATA_FREE(indata);
1326         return ret;
1327     }
1328     for (i=0;i<count;i++)
1329     {
1330         ret = _cal_ipc_marshal_int(ids[i],indata);
1331         if (ret != CALENDAR_ERROR_NONE)
1332         {
1333             ERR("marshal fail");
1334             CAL_IPC_DATA_FREE(indata);
1335             return ret;
1336         }
1337     }
1338
1339     async_data = (cal_client_db_async_userdata_s*)malloc(sizeof(cal_client_db_async_userdata_s));
1340     if (async_data == NULL)
1341     {
1342         ERR("malloc fail !");
1343         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1344         CAL_IPC_DATA_FREE(indata);
1345         return ret;
1346     }
1347     async_data->callback = callback;
1348     async_data->user_data = user_data;
1349     if (_cal_client_ipc_call_async(CAL_IPC_MODULE,CAL_IPC_SERVER_DB_DELETE_RECORDS,
1350             indata,__cal_client_db_delete_records_cb,async_data) != 0)
1351     {
1352         ERR("pims_ipc_call_async failed");
1353         CAL_IPC_DATA_FREE(indata);
1354         return CALENDAR_ERROR_IPC;
1355     }
1356
1357     CAL_IPC_DATA_FREE(indata);
1358
1359     return ret;
1360 }
1361
1362 API int calendar_db_get_changes_by_version(const char* view_uri, int calendar_book_id, int calendar_db_version, calendar_list_h* record_list, int* current_calendar_db_version )
1363 {
1364     int ret = CALENDAR_ERROR_NONE;
1365     pims_ipc_data_h indata = NULL;
1366     pims_ipc_data_h outdata = NULL;
1367
1368     retvm_if(view_uri==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"view_uri is NULL");
1369     retvm_if(record_list==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record_list is NULL");
1370     retvm_if(current_calendar_db_version==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"current_calendar_db_version is NULL");
1371
1372     // make indata
1373     indata = pims_ipc_data_create(0);
1374     if (indata == NULL)
1375     {
1376         ERR("ipc data created fail !");
1377         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1378         return ret;
1379     }
1380     ret = _cal_ipc_marshal_char(view_uri,indata);
1381     if (ret != CALENDAR_ERROR_NONE)
1382     {
1383         ERR("marshal fail");
1384         CAL_IPC_DATA_FREE(indata);
1385         return ret;
1386     }
1387     ret = _cal_ipc_marshal_int(calendar_book_id,indata);
1388     if (ret != CALENDAR_ERROR_NONE)
1389     {
1390         ERR("marshal fail");
1391         CAL_IPC_DATA_FREE(indata);
1392         return ret;
1393     }
1394     ret = _cal_ipc_marshal_int(calendar_db_version,indata);
1395     if (ret != CALENDAR_ERROR_NONE)
1396     {
1397         ERR("marshal fail");
1398         CAL_IPC_DATA_FREE(indata);
1399         return ret;
1400     }
1401
1402     // ipc call
1403     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_CHANGES_BY_VERSION, indata, &outdata) != 0)
1404     {
1405         ERR("pims_ipc_call failed");
1406         CAL_IPC_DATA_FREE(indata);
1407         return CALENDAR_ERROR_IPC;
1408     }
1409
1410     CAL_IPC_DATA_FREE(indata);
1411
1412     if (outdata)
1413     {
1414         // check outdata
1415         unsigned int size = 0;
1416         ret = *(int*) pims_ipc_data_get(outdata,&size);
1417
1418         if (ret == CALENDAR_ERROR_NONE)
1419         {
1420             ret = _cal_ipc_unmarshal_list(outdata,record_list);
1421
1422             if (ret == CALENDAR_ERROR_NONE)
1423             {
1424                 ret = _cal_ipc_unmarshal_int(outdata,current_calendar_db_version);
1425             }
1426         }
1427
1428         pims_ipc_data_destroy(outdata);
1429     }
1430     else
1431     {
1432         ERR("ipc outdata is NULL");
1433         return CALENDAR_ERROR_IPC;
1434     }
1435
1436     return ret;
1437 }
1438
1439 API int calendar_db_get_current_version(int* calendar_db_version)
1440 {
1441     int ret = CALENDAR_ERROR_NONE;
1442     pims_ipc_data_h indata = NULL;
1443     pims_ipc_data_h outdata = NULL;
1444
1445     retvm_if(calendar_db_version==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"calendar_db_version is null");
1446
1447     // ipc call
1448     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_CURRENT_VERSION, indata, &outdata) != 0)
1449     {
1450         ERR("pims_ipc_call failed");
1451         return CALENDAR_ERROR_IPC;
1452     }
1453
1454     if (outdata)
1455     {
1456         // check outdata
1457         unsigned int size = 0;
1458         ret = *(int*) pims_ipc_data_get(outdata,&size);
1459         if (ret == CALENDAR_ERROR_NONE)
1460         {
1461             ret = _cal_ipc_unmarshal_int(outdata,calendar_db_version);
1462         }
1463         pims_ipc_data_destroy(outdata);
1464     }
1465     else
1466     {
1467         ERR("ipc outdata is NULL");
1468         return CALENDAR_ERROR_IPC;
1469     }
1470
1471     return ret;
1472 }
1473
1474 API int calendar_db_add_changed_cb(const char* view_uri, calendar_db_changed_cb callback, void* user_data )
1475 {
1476     CAL_FN_CALL;
1477     int ret;
1478     cal_record_type_e type = CAL_RECORD_TYPE_INVALID;
1479
1480     retv_if(NULL == view_uri || NULL == callback , CALENDAR_ERROR_INVALID_PARAMETER);
1481
1482     type = _cal_view_get_type(view_uri);
1483
1484     switch(type)
1485     {
1486     case CAL_RECORD_TYPE_CALENDAR:
1487         ret = _cal_inotify_subscribe(CAL_NOTI_TYPE_CALENDAR, CAL_NOTI_CALENDAR_CHANGED, callback, user_data);
1488         break;
1489     case CAL_RECORD_TYPE_EVENT:
1490         ret = _cal_inotify_subscribe(CAL_NOTI_TYPE_EVENT, CAL_NOTI_EVENT_CHANGED, callback, user_data);
1491         break;
1492     case CAL_RECORD_TYPE_TODO:
1493         ret = _cal_inotify_subscribe(CAL_NOTI_TYPE_TODO, CAL_NOTI_TODO_CHANGED, callback, user_data);
1494         break;
1495     default:
1496         ERR("Invalid view_uri(%s)", view_uri);
1497         return CALENDAR_ERROR_INVALID_PARAMETER;
1498     }
1499     retvm_if(CALENDAR_ERROR_NONE != ret, ret, "_cal_inotify_subscribe() Failed(%d)", ret);
1500
1501     return CALENDAR_ERROR_NONE;
1502 }
1503
1504 API int calendar_db_remove_changed_cb( const char* view_uri, calendar_db_changed_cb callback, void* user_data )
1505 {
1506     CAL_FN_CALL;
1507     int ret;
1508     cal_record_type_e type = CAL_RECORD_TYPE_INVALID;
1509
1510     retv_if(NULL == view_uri || NULL == callback , CALENDAR_ERROR_INVALID_PARAMETER);
1511
1512     type = _cal_view_get_type(view_uri);
1513
1514     switch(type)
1515     {
1516     case CAL_RECORD_TYPE_CALENDAR:
1517         ret = _cal_inotify_unsubscribe_with_data(CAL_NOTI_CALENDAR_CHANGED, callback, user_data);
1518         break;
1519     case CAL_RECORD_TYPE_EVENT:
1520         ret = _cal_inotify_unsubscribe_with_data(CAL_NOTI_EVENT_CHANGED, callback, user_data);
1521         break;
1522     case CAL_RECORD_TYPE_TODO:
1523         ret = _cal_inotify_unsubscribe_with_data(CAL_NOTI_TODO_CHANGED, callback, user_data);
1524         break;
1525     default:
1526         ERR("Invalid view_uri(%s)", view_uri);
1527         return CALENDAR_ERROR_INVALID_PARAMETER;
1528     }
1529     retvm_if(CALENDAR_ERROR_NONE != ret, ret, "_cal_inotify_unsubscribe_with_data() Failed(%d)", ret);
1530
1531     return CALENDAR_ERROR_NONE;
1532 }
1533
1534 API int calendar_db_insert_vcalendars(const char* vcalendar_stream, int **record_id_array, int *count)
1535 {
1536     int ret = CALENDAR_ERROR_NONE;
1537     pims_ipc_data_h indata = NULL;
1538     pims_ipc_data_h outdata = NULL;
1539     int i = 0;
1540
1541     retvm_if(NULL == vcalendar_stream, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1542
1543     // make indata
1544     indata = pims_ipc_data_create(0);
1545     if (indata == NULL)
1546     {
1547         ERR("ipc data created fail !");
1548         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1549         return ret;
1550     }
1551     ret = _cal_ipc_marshal_char(vcalendar_stream,indata);
1552     if (ret != CALENDAR_ERROR_NONE)
1553     {
1554         ERR("marshal fail");
1555         CAL_IPC_DATA_FREE(indata);
1556         return ret;
1557     }
1558     // ipc call
1559     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_INSERT_VCALENDARS, indata, &outdata) != 0)
1560     {
1561         ERR("pims_ipc_call failed");
1562         CAL_IPC_DATA_FREE(indata);
1563         return CALENDAR_ERROR_IPC;
1564     }
1565     CAL_IPC_DATA_FREE(indata);
1566     if (outdata)
1567     {
1568         // check outdata
1569         unsigned int size = 0;
1570         ret = *(int*) pims_ipc_data_get(outdata,&size);
1571
1572         if (ret == CALENDAR_ERROR_NONE)
1573         {
1574             int transaction_ver = 0;
1575             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
1576             _cal_client_ipc_set_change_version(transaction_ver);
1577         }
1578
1579         if (ret == CALENDAR_ERROR_NONE && count != NULL && record_id_array != NULL)
1580         {
1581             int *ids = NULL;
1582
1583             *count = *(int*) pims_ipc_data_get(outdata,&size);
1584
1585             ids = (int*)malloc(sizeof(int)*(*count));
1586             if(ids == NULL)
1587             {
1588                 pims_ipc_data_destroy(outdata);
1589                 ERR("malloc fail");
1590                 return CALENDAR_ERROR_OUT_OF_MEMORY;
1591             }
1592             for(i=0;i<(*count);i++)
1593             {
1594                 ids[i] = *(int*) pims_ipc_data_get(outdata,&size);
1595             }
1596
1597             *record_id_array = ids;
1598         }
1599         pims_ipc_data_destroy(outdata);
1600     }
1601     else
1602     {
1603         ERR("ipc outdata is NULL");
1604         return CALENDAR_ERROR_IPC;
1605     }
1606
1607     return ret;
1608 }
1609
1610 API int calendar_db_insert_vcalendars_async(const char* vcalendar_stream, calendar_db_insert_result_cb callback, void *user_data)
1611 {
1612     int ret = CALENDAR_ERROR_NONE;
1613     pims_ipc_data_h indata = NULL;
1614     cal_client_db_async_insert_userdata_s *async_data = NULL;
1615
1616     retvm_if(vcalendar_stream==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"list is NULL");
1617     retvm_if(callback==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"list is NULL");
1618
1619     // make indata
1620     indata = pims_ipc_data_create(0);
1621     if (indata == NULL)
1622     {
1623         ERR("ipc data created fail !");
1624         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1625         return ret;
1626     }
1627     ret = _cal_ipc_marshal_char(vcalendar_stream,indata);
1628     if (ret != CALENDAR_ERROR_NONE)
1629     {
1630         ERR("marshal fail");
1631         CAL_IPC_DATA_FREE(indata);
1632
1633         return ret;
1634     }
1635
1636     async_data = (cal_client_db_async_insert_userdata_s*)malloc(sizeof(cal_client_db_async_insert_userdata_s));
1637     if (async_data == NULL)
1638     {
1639         ERR("malloc fail !");
1640         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1641         CAL_IPC_DATA_FREE(indata);
1642         return ret;
1643     }
1644     async_data->callback = callback;
1645     async_data->user_data = user_data;
1646
1647     if (_cal_client_ipc_call_async(CAL_IPC_MODULE,CAL_IPC_SERVER_DB_INSERT_VCALENDARS,
1648             indata,__cal_client_db_insert_vcalendars_cb,async_data) != 0)
1649     {
1650         ERR("pims_ipc_call_async failed");
1651         CAL_IPC_DATA_FREE(indata);
1652         return CALENDAR_ERROR_IPC;
1653     }
1654
1655     CAL_IPC_DATA_FREE(indata);
1656
1657     return ret;
1658 }
1659
1660 API int calendar_db_replace_vcalendars(const char* vcalendar_stream, int *record_id_array, int count)
1661 {
1662     int ret = CALENDAR_ERROR_NONE;
1663     pims_ipc_data_h indata = NULL;
1664     pims_ipc_data_h outdata = NULL;
1665     int i = 0;
1666
1667     retvm_if(NULL == vcalendar_stream, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1668     retvm_if(NULL == record_id_array, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1669     retvm_if(count <= 0, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1670
1671     // make indata
1672     indata = pims_ipc_data_create(0);
1673     if (indata == NULL)
1674     {
1675         ERR("ipc data created fail !");
1676         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1677         return ret;
1678     }
1679     ret = _cal_ipc_marshal_char(vcalendar_stream,indata);
1680     if (ret != CALENDAR_ERROR_NONE)
1681     {
1682         ERR("marshal fail");
1683         CAL_IPC_DATA_FREE(indata);
1684         return ret;
1685     }
1686     ret = _cal_ipc_marshal_int(count,indata);
1687     if (ret != CALENDAR_ERROR_NONE)
1688     {
1689         ERR("marshal fail");
1690         CAL_IPC_DATA_FREE(indata);
1691         return ret;
1692     }
1693     for(i=0;i<count;i++)
1694     {
1695         ret = _cal_ipc_marshal_int(record_id_array[i],indata);
1696         if (ret != CALENDAR_ERROR_NONE)
1697         {
1698             ERR("marshal fail");
1699             CAL_IPC_DATA_FREE(indata);
1700             return ret;
1701         }
1702     }
1703
1704     // ipc call
1705     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_VCALENDARS, indata, &outdata) != 0)
1706     {
1707         ERR("pims_ipc_call failed");
1708         CAL_IPC_DATA_FREE(indata);
1709         return CALENDAR_ERROR_IPC;
1710     }
1711     CAL_IPC_DATA_FREE(indata);
1712     if (outdata)
1713     {
1714         // check outdata
1715         unsigned int size = 0;
1716         ret = *(int*) pims_ipc_data_get(outdata,&size);
1717
1718         if (ret == CALENDAR_ERROR_NONE)
1719         {
1720             int transaction_ver = 0;
1721             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
1722             _cal_client_ipc_set_change_version(transaction_ver);
1723         }
1724
1725         pims_ipc_data_destroy(outdata);
1726     }
1727     else
1728     {
1729         ERR("ipc outdata is NULL");
1730         return CALENDAR_ERROR_IPC;
1731     }
1732
1733     return ret;
1734 }
1735
1736 API int calendar_db_replace_vcalendars_async(const char* vcalendar_stream, int *record_id_array, int count, calendar_db_result_cb callback, void *user_data)
1737 {
1738     int ret = CALENDAR_ERROR_NONE;
1739     pims_ipc_data_h indata = NULL;
1740     cal_client_db_async_userdata_s *async_data = NULL;
1741     int i = 0;
1742
1743     retvm_if(NULL == vcalendar_stream, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1744     retvm_if(NULL == record_id_array, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1745     retvm_if(count <= 0, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1746
1747     // make indata
1748     indata = pims_ipc_data_create(0);
1749     if (indata == NULL)
1750     {
1751         ERR("ipc data created fail !");
1752         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1753         return ret;
1754     }
1755     ret = _cal_ipc_marshal_char(vcalendar_stream,indata);
1756     if (ret != CALENDAR_ERROR_NONE)
1757     {
1758         ERR("marshal fail");
1759         CAL_IPC_DATA_FREE(indata);
1760         return ret;
1761     }
1762     ret = _cal_ipc_marshal_int(count,indata);
1763     if (ret != CALENDAR_ERROR_NONE)
1764     {
1765         ERR("marshal fail");
1766         CAL_IPC_DATA_FREE(indata);
1767         return ret;
1768     }
1769     for(i=0;i<count;i++)
1770     {
1771         ret = _cal_ipc_marshal_int(record_id_array[i],indata);
1772         if (ret != CALENDAR_ERROR_NONE)
1773         {
1774             ERR("marshal fail");
1775             CAL_IPC_DATA_FREE(indata);
1776             return ret;
1777         }
1778     }
1779
1780     async_data = (cal_client_db_async_userdata_s*)malloc(sizeof(cal_client_db_async_userdata_s));
1781     if (async_data == NULL)
1782     {
1783         ERR("malloc fail !");
1784         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1785         CAL_IPC_DATA_FREE(indata);
1786         return ret;
1787     }
1788     async_data->callback = callback;
1789     async_data->user_data = user_data;
1790
1791     if (_cal_client_ipc_call_async(CAL_IPC_MODULE,CAL_IPC_SERVER_DB_REPLACE_VCALENDARS,
1792             indata,__cal_client_db_replace_vcalendars_cb,async_data) != 0)
1793     {
1794         ERR("pims_ipc_call_async failed");
1795         CAL_IPC_DATA_FREE(indata);
1796         return CALENDAR_ERROR_IPC;
1797     }
1798
1799     CAL_IPC_DATA_FREE(indata);
1800
1801     return ret;
1802 }
1803
1804 API int calendar_db_replace_record(calendar_record_h record, int record_id)
1805 {
1806     int ret = CALENDAR_ERROR_NONE;
1807     pims_ipc_data_h indata = NULL;
1808     pims_ipc_data_h outdata = NULL;
1809
1810     retvm_if(record==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record is NULL");
1811     retvm_if(record_id < 0, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1812
1813     // make indata
1814     indata = pims_ipc_data_create(0);
1815     if (indata == NULL)
1816     {
1817         ERR("ipc data created fail !");
1818         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1819         return ret;
1820     }
1821     ret = _cal_ipc_marshal_record(record,indata);
1822     if (ret != CALENDAR_ERROR_NONE)
1823     {
1824         ERR("marshal fail");
1825         CAL_IPC_DATA_FREE(indata);
1826         return ret;
1827     }
1828     ret = _cal_ipc_marshal_int(record_id,indata);
1829     if (ret != CALENDAR_ERROR_NONE)
1830     {
1831         ERR("marshal fail");
1832         CAL_IPC_DATA_FREE(indata);
1833         return ret;
1834     }
1835
1836     // ipc call
1837     if (_cal_client_ipc_call(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_RECORD, indata, &outdata) != 0)
1838     {
1839         ERR("pims_ipc_call failed");
1840         CAL_IPC_DATA_FREE(indata);
1841         return CALENDAR_ERROR_IPC;
1842     }
1843
1844     CAL_IPC_DATA_FREE(indata);
1845
1846     if (outdata)
1847     {
1848         // check outdata
1849         unsigned int size = 0;
1850         ret = *(int*) pims_ipc_data_get(outdata,&size);
1851         if (ret == CALENDAR_ERROR_NONE)
1852         {
1853             int transaction_ver = 0;
1854             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
1855             _cal_client_ipc_set_change_version(transaction_ver);
1856         }
1857         pims_ipc_data_destroy(outdata);
1858     }
1859     else
1860     {
1861         ERR("ipc outdata is NULL");
1862         return CALENDAR_ERROR_IPC;
1863     }
1864
1865     return ret;
1866 }
1867
1868 API int calendar_db_replace_records(calendar_list_h record_list, int *record_id_array, int count)
1869 {
1870     int ret = CALENDAR_ERROR_NONE;
1871     pims_ipc_data_h indata = NULL;
1872     pims_ipc_data_h outdata = NULL;
1873     int i = 0;
1874
1875     retvm_if(record_list==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record is NULL");
1876     retvm_if(record_id_array==NULL,CALENDAR_ERROR_INVALID_PARAMETER,"record_id_array is NULL");
1877     retvm_if(count <= 0, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1878
1879     // make indata
1880     indata = pims_ipc_data_create(0);
1881     if (indata == NULL)
1882     {
1883         ERR("ipc data created fail !");
1884         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1885         return ret;
1886     }
1887     ret = _cal_ipc_marshal_list(record_list,indata);
1888     if (ret != CALENDAR_ERROR_NONE)
1889     {
1890         ERR("marshal fail");
1891         CAL_IPC_DATA_FREE(indata);
1892         return ret;
1893     }
1894     ret = _cal_ipc_marshal_int(count,indata);
1895     if (ret != CALENDAR_ERROR_NONE)
1896     {
1897         ERR("marshal fail");
1898         CAL_IPC_DATA_FREE(indata);
1899         return ret;
1900     }
1901     for(i=0;i<count;i++)
1902     {
1903         ret = _cal_ipc_marshal_int(record_id_array[i],indata);
1904         if (ret != CALENDAR_ERROR_NONE)
1905         {
1906             ERR("marshal fail");
1907             CAL_IPC_DATA_FREE(indata);
1908             return ret;
1909         }
1910     }
1911
1912     // ipc call
1913     if (_cal_client_ipc_call( CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_RECORDS, indata, &outdata) != 0)
1914     {
1915         ERR("pims_ipc_call failed");
1916         CAL_IPC_DATA_FREE(indata);
1917         return CALENDAR_ERROR_IPC;
1918     }
1919
1920     CAL_IPC_DATA_FREE(indata);
1921
1922     if (outdata)
1923     {
1924         // check outdata
1925         unsigned int size = 0;
1926         ret = *(int*) pims_ipc_data_get(outdata,&size);
1927         if (ret == CALENDAR_ERROR_NONE)
1928         {
1929             int transaction_ver = 0;
1930             transaction_ver = *(int*)pims_ipc_data_get(outdata,&size);
1931             _cal_client_ipc_set_change_version(transaction_ver);
1932         }
1933         pims_ipc_data_destroy(outdata);
1934     }
1935     else
1936     {
1937         ERR("ipc outdata is NULL");
1938         return CALENDAR_ERROR_IPC;
1939     }
1940
1941     return ret;
1942 }
1943
1944 API int calendar_db_replace_records_async(calendar_list_h record_list, int *record_id_array, int count, calendar_db_result_cb callback, void *user_data)
1945 {
1946     int ret = CALENDAR_ERROR_NONE;
1947     pims_ipc_data_h indata = NULL;
1948     cal_client_db_async_userdata_s *async_data = NULL;
1949     int i = 0;
1950
1951     retvm_if(NULL == record_list, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1952     retvm_if(NULL == record_id_array, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1953     retvm_if(count <= 0, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
1954
1955     // make indata
1956     indata = pims_ipc_data_create(0);
1957     if (indata == NULL)
1958     {
1959         ERR("ipc data created fail !");
1960         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1961         return ret;
1962     }
1963     ret = _cal_ipc_marshal_list(record_list,indata);
1964     if (ret != CALENDAR_ERROR_NONE)
1965     {
1966         ERR("marshal fail");
1967         CAL_IPC_DATA_FREE(indata);
1968         return ret;
1969     }
1970     ret = _cal_ipc_marshal_int(count,indata);
1971     if (ret != CALENDAR_ERROR_NONE)
1972     {
1973         ERR("marshal fail");
1974         CAL_IPC_DATA_FREE(indata);
1975         return ret;
1976     }
1977     for(i=0;i<count;i++)
1978     {
1979         ret = _cal_ipc_marshal_int(record_id_array[i],indata);
1980         if (ret != CALENDAR_ERROR_NONE)
1981         {
1982             ERR("marshal fail");
1983             CAL_IPC_DATA_FREE(indata);
1984             return ret;
1985         }
1986     }
1987
1988     async_data = (cal_client_db_async_userdata_s*)malloc(sizeof(cal_client_db_async_userdata_s));
1989     if (async_data == NULL)
1990     {
1991         ERR("malloc fail !");
1992         ret = CALENDAR_ERROR_OUT_OF_MEMORY;
1993         CAL_IPC_DATA_FREE(indata);
1994         return ret;
1995     }
1996     async_data->callback = callback;
1997     async_data->user_data = user_data;
1998
1999     if (_cal_client_ipc_call_async(CAL_IPC_MODULE,CAL_IPC_SERVER_DB_REPLACE_RECORDS,
2000             indata,__cal_client_db_replace_records_cb,async_data) != 0)
2001     {
2002         ERR("pims_ipc_call_async failed");
2003         CAL_IPC_DATA_FREE(indata);
2004         return CALENDAR_ERROR_IPC;
2005     }
2006
2007     CAL_IPC_DATA_FREE(indata);
2008
2009     return ret;
2010 }
2011
2012 API int calendar_db_get_last_change_version(int* last_version)
2013 {
2014     int ret = CALENDAR_ERROR_NONE;
2015
2016     retvm_if(NULL == last_version, CALENDAR_ERROR_INVALID_PARAMETER, "Invalid parameter");
2017     *last_version = _cal_client_ipc_get_change_version();
2018     return ret;
2019 }