common/dbus/cal_dbus_helper.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 <stdlib.h>
  21 #include <string.h>
  22 #include <glib.h>
  23
  24 #include "calendar.h"
  25 #include "cal_view.h"
  26 #include "cal_internal.h"
  27 #include "cal_typedef.h"
  28 #include "cal_handle.h"
  29 #include "cal_utils.h"
  30
  31 #define CAL_DBUS_SET_STRING(x) (x) ? x : ""
  32 #define CAL_DBUS_GET_STRING(x) do { \
  33         x = (NULL != x) ? strdup(x) : NULL; \
  34 } while (0)
  35
  36 GVariant* cal_dbus_utils_null_to_gvariant(void)
  37 {
  38         GVariant *value = NULL;
  39         value = g_variant_new("(s)", "");
  40         return value;
  41 }
  42
  43 GVariant *cal_dbus_utils_char_to_gvariant(unsigned char *ch, int count)
  44 {
  45         GVariantBuilder builder;
  46         g_variant_builder_init(&builder, G_VARIANT_TYPE("ay"));
  47
  48         int i;
  49         for (i = 0; i < count; i++)
  50                 g_variant_builder_add(&builder, "y", ch[i]);
  51
  52         return g_variant_builder_end(&builder);
  53 }
  54
  55 int cal_dbus_utils_gvariant_to_char(GVariant *arg_char, int count,
  56                 unsigned char **out_flag)
  57 {
  58         if (0 == count)
  59                 return  CALENDAR_ERROR_NONE;
  60
  61         GVariantIter *iter_char = NULL;
  62         g_variant_get(arg_char, "ay", &iter_char);
  63
  64         unsigned char *flag = calloc(count, sizeof(unsigned char));
  65         if (NULL == flag) {
  66                 ERR("calloc() Fail");
  67                 return CALENDAR_ERROR_OUT_OF_MEMORY;
  68         }
  69         int i = 0;
  70         for (i = 0; i < count; i++)
  71                 g_variant_iter_loop(iter_char, "y", &flag[i]);
  72
  73         *out_flag = flag;
  74         return CALENDAR_ERROR_NONE;
  75 }
  76
  77 GVariant* cal_dbus_utils_common_to_gvariant(cal_record_s *rec)
  78 {
  79         GVariant *arg_flags = cal_dbus_utils_char_to_gvariant(rec->properties_flags,
  80                         rec->properties_max_count);
  81         GVariant *value = NULL;
  82         value = g_variant_new("(isuvy)",
  83                         rec->type,
  84                         CAL_DBUS_SET_STRING(rec->view_uri),
  85                         rec->properties_max_count,
  86                         arg_flags,
  87                         rec->property_flag);
  88         return value;
  89 }
  90
  91 int cal_dbus_utils_gvariant_to_common(GVariant *arg_common, calendar_record_h *record)
  92 {
  93         cal_record_s rec = {0};
  94         GVariant *arg_flags = NULL;
  95         g_variant_get(arg_common, "(i&suvy)",
  96                         &rec.type,
  97                         rec.view_uri,
  98                         &rec.properties_max_count,
  99                         &arg_flags,
 100                         &rec.property_flag);
 101         CAL_DBUS_GET_STRING(rec.view_uri);
 102         cal_dbus_utils_gvariant_to_char(arg_flags, rec.properties_max_count,
 103                         &rec.properties_flags);
 104
 105         cal_record_s *p = ((cal_record_s *)(*record));
 106
 107         p->properties_max_count = rec.properties_max_count;
 108         p->properties_flags = rec.properties_flags;
 109
 110         return CALENDAR_ERROR_NONE;
 111 }
 112
 113 GVariant* cal_dbus_utils_handle_to_gvariant(calendar_h handle)
 114 {
 115         GVariant *value = NULL;
 116         cal_s *p = (cal_s *)handle;
 117         value = g_variant_new("(ii)",
 118                         p->version, p->connection_count);
 119         return value;
 120 }
 121
 122 static GVariant* _caltime_to_gvariant(calendar_time_s *ct)
 123 {
 124         GVariant *value = NULL;
 125         switch (ct->type) {
 126         case CALENDAR_TIME_UTIME:
 127                 value = g_variant_new("(x)", ct->time.utime);
 128                 break;
 129         case CALENDAR_TIME_LOCALTIME:
 130                 value = g_variant_new("(iiiiii)",
 131                                 ct->time.date.year, ct->time.date.month, ct->time.date.mday,
 132                                 ct->time.date.hour, ct->time.date.minute, ct->time.date.second);
 133                 break;
 134         }
 135         return value;
 136 }
 137
 138 static int _gvariant_to_caltime(int type, GVariant *arg_caltime, calendar_time_s *ct)
 139 {
 140         switch (type) {
 141         case CALENDAR_TIME_UTIME:
 142                 g_variant_get(arg_caltime, "(x)", &ct->time.utime);
 143                 break;
 144         case CALENDAR_TIME_LOCALTIME:
 145                 g_variant_get(arg_caltime, "(iiiiii)",
 146                                 &ct->time.date.year, &ct->time.date.month, &ct->time.date.mday,
 147                                 &ct->time.date.hour, &ct->time.date.minute, &ct->time.date.second);
 148                 break;
 149         }
 150         return CALENDAR_ERROR_NONE;
 151 }
 152
 153 GVariant *cal_dbus_utils_ids_to_gvariant(int *ids, int count)
 154 {
 155         GVariantBuilder builder;
 156         g_variant_builder_init(&builder, G_VARIANT_TYPE("ai"));
 157
 158         int i;
 159         for (i = 0; i < count; i++)
 160                 g_variant_builder_add(&builder, "i", ids[i]);
 161
 162         return g_variant_builder_end(&builder);
 163 }
 164
 165 static void _set_attribute_filter(GVariantBuilder *builder, cal_attribute_filter_s* filter)
 166 {
 167         g_variant_builder_add(builder, "v", g_variant_new("i", filter->filter_type));
 168         g_variant_builder_add(builder, "v", g_variant_new("i", filter->property_id));
 169         g_variant_builder_add(builder, "v", g_variant_new("i", filter->match));
 170         switch (filter->filter_type) {
 171         case CAL_FILTER_STR:
 172                 g_variant_builder_add(builder, "v",
 173                                 g_variant_new("s", CAL_DBUS_SET_STRING(filter->value.s)));
 174                 break;
 175         case CAL_FILTER_INT:
 176                 g_variant_builder_add(builder, "v", g_variant_new("i", filter->value.i));
 177                 break;
 178         case CAL_FILTER_DOUBLE:
 179                 g_variant_builder_add(builder, "v", g_variant_new("d", filter->value.d));
 180                 break;
 181         case CAL_FILTER_LLI:
 182                 g_variant_builder_add(builder, "v", g_variant_new("x", filter->value.lli));
 183                 break;
 184         case CAL_FILTER_CALTIME:
 185                 g_variant_builder_add(builder, "v", g_variant_new("(iv)", filter->value.caltime.type,
 186                                 _caltime_to_gvariant(&filter->value.caltime)));
 187                 break;
 188         default:
 189                 ERR("Invalid parameter(0x%x)", filter->property_id);
 190                 break;
 191         }
 192 }
 193
 194 static void _set_composite_filter(GVariantBuilder *builder, cal_composite_filter_s *filter)
 195 {
 196         g_variant_builder_add(builder, "v", g_variant_new("i", filter->filter_type));
 197         g_variant_builder_add(builder, "v",
 198                 g_variant_new("s", CAL_DBUS_SET_STRING(filter->view_uri)));
 199
 200         do {
 201                 if (NULL == filter->filters) {
 202                         ERR("No filters");
 203                         g_variant_builder_add(builder, "v", g_variant_new("i", 0));
 204                         break;
 205                 }
 206                 GSList *cursor = NULL;
 207                 int filter_count = g_slist_length(filter->filters);
 208                 g_variant_builder_add(builder, "v", g_variant_new("i", filter_count));
 209                 cursor = filter->filters;
 210                 while (cursor) {
 211                         cal_filter_s* child_filter = (cal_filter_s*)cursor->data;
 212                         if (CAL_FILTER_COMPOSITE == child_filter->filter_type)
 213                                 _set_composite_filter(builder, (cal_composite_filter_s *)child_filter);
 214                         else
 215                                 _set_attribute_filter(builder, (cal_attribute_filter_s *)child_filter);
 216
 217                         cursor = g_slist_next(cursor);
 218                 }
 219         } while (0);
 220
 221         do {
 222                 if (NULL == filter->filter_ops) {
 223                         ERR("No operation");
 224                         g_variant_builder_add(builder, "v", g_variant_new("i", 0));
 225                         break;
 226                 }
 227                 int ops_count = g_slist_length(filter->filter_ops);
 228                 g_variant_builder_add(builder, "v", g_variant_new("i", ops_count));
 229                 GSList *cursor = NULL;
 230                 cursor = filter->filter_ops;
 231                 while (cursor) {
 232                         calendar_filter_operator_e op = (calendar_filter_operator_e)cursor->data;
 233                         g_variant_builder_add(builder, "v", g_variant_new("i", op));
 234                         cursor = g_slist_next(cursor);
 235                 }
 236         } while (0);
 237 }
 238
 239 static GVariant *_filter_to_gvariant(cal_composite_filter_s *f)
 240 {
 241         GVariantBuilder builder;
 242         g_variant_builder_init(&builder, G_VARIANT_TYPE("av"));
 243         _set_composite_filter(&builder, f);
 244         return g_variant_builder_end(&builder);
 245 }
 246
 247 static GVariant *_projection_to_gvariant(cal_query_s *q)
 248 {
 249         int i;
 250         GVariantBuilder builder;
 251         g_variant_builder_init(&builder, G_VARIANT_TYPE("au"));
 252         for (i = 0; i < q->projection_count; i++)
 253                 g_variant_builder_add(&builder, "u", q->projection[i]);
 254
 255         return g_variant_builder_end(&builder);
 256 }
 257
 258 GVariant *cal_dbus_utils_query_to_gvariant(calendar_query_h query)
 259 {
 260         RETV_IF(NULL == query, NULL);
 261
 262         cal_query_s *q = (cal_query_s *)query;
 263         int has_filter = 0;
 264         GVariant *arg_filter = NULL;
 265         if (q->filter) {
 266                 has_filter = 1;
 267                 arg_filter = _filter_to_gvariant(q->filter);
 268         } else {
 269                 has_filter = 0;
 270                 arg_filter = cal_dbus_utils_null_to_gvariant();
 271         }
 272
 273         GVariant *arg_projection = NULL;
 274         if (q->projection_count)
 275                 arg_projection = _projection_to_gvariant(q);
 276         else
 277                 arg_projection = cal_dbus_utils_null_to_gvariant();
 278
 279         GVariant *value = NULL;
 280         value = g_variant_new("(siviviii)",
 281                         CAL_DBUS_SET_STRING(q->view_uri), has_filter, arg_filter,
 282                         q->projection_count, arg_projection,
 283                         q->sort_property_id, (int)q->asc, (int)q->distinct);
 284
 285         return value;
 286 }
 287
 288
 289 static GVariant *_book_to_gvariant(calendar_record_h record)
 290 {
 291         RETV_IF(NULL == record, NULL);
 292
 293         GVariant *value = NULL;
 294         cal_book_s *p = (cal_book_s *)record;
 295         value = g_variant_new("(iisissssiiiissssi)",
 296                         p->index, p->store_type,
 297                         CAL_DBUS_SET_STRING(p->uid),
 298                         p->updated,
 299                         CAL_DBUS_SET_STRING(p->name),
 300                         CAL_DBUS_SET_STRING(p->description),
 301                         CAL_DBUS_SET_STRING(p->color),
 302                         CAL_DBUS_SET_STRING(p->location),
 303                         p->visibility, p->sync_event, p->is_deleted, p->account_id,
 304                         CAL_DBUS_SET_STRING(p->sync_data1),
 305                         CAL_DBUS_SET_STRING(p->sync_data2),
 306                         CAL_DBUS_SET_STRING(p->sync_data3),
 307                         CAL_DBUS_SET_STRING(p->sync_data4),
 308                         p->mode);
 309         return value;
 310 }
 311
 312 static GVariant *_only_event_to_gvariant(calendar_record_h record)
 313 {
 314         GVariant *value = NULL;
 315         cal_event_s *p = (cal_event_s *)record;
 316         RETV_IF(NULL == record, NULL);
 317
 318         GVariant *arg_until = _caltime_to_gvariant(&p->until);
 319         GVariant *arg_start = _caltime_to_gvariant(&p->start);
 320         GVariant *arg_end = _caltime_to_gvariant(&p->end);
 321
 322         value = g_variant_new("(iisssssiiiiiiisssiddixixiiiviisssssssssissiiiissssivsivsi)",
 323                         p->index, p->calendar_id,
 324                         CAL_DBUS_SET_STRING(p->summary),
 325                         CAL_DBUS_SET_STRING(p->description),
 326                         CAL_DBUS_SET_STRING(p->location),
 327                         CAL_DBUS_SET_STRING(p->categories),
 328                         CAL_DBUS_SET_STRING(p->exdate),
 329                         p->event_status, p->priority, p->timezone, p->contact_id, p->busy_status,
 330                         p->sensitivity, p->meeting_status,
 331                         CAL_DBUS_SET_STRING(p->uid),
 332                         CAL_DBUS_SET_STRING(p->organizer_name),
 333                         CAL_DBUS_SET_STRING(p->organizer_email),
 334                         p->original_event_id, p->latitude, p->longitude, p->email_id,
 335                         p->created_time, p->is_deleted, p->last_mod, p->freq, p->range_type,
 336                         p->until.type, arg_until, p->count, p->interval,
 337                         CAL_DBUS_SET_STRING(p->bysecond),
 338                         CAL_DBUS_SET_STRING(p->byminute),
 339                         CAL_DBUS_SET_STRING(p->byhour),
 340                         CAL_DBUS_SET_STRING(p->byday),
 341                         CAL_DBUS_SET_STRING(p->bymonthday),
 342                         CAL_DBUS_SET_STRING(p->byyearday),
 343                         CAL_DBUS_SET_STRING(p->byweekno),
 344                         CAL_DBUS_SET_STRING(p->bymonth),
 345                         CAL_DBUS_SET_STRING(p->bysetpos),
 346                         p->wkst,
 347                         CAL_DBUS_SET_STRING(p->recurrence_id),
 348                         CAL_DBUS_SET_STRING(p->rdate),
 349                         p->has_attendee, p->has_alarm, p->system_type, p->updated,
 350                         CAL_DBUS_SET_STRING(p->sync_data1),
 351                         CAL_DBUS_SET_STRING(p->sync_data2),
 352                         CAL_DBUS_SET_STRING(p->sync_data3),
 353                         CAL_DBUS_SET_STRING(p->sync_data4),
 354                         p->start.type, arg_start,
 355                         CAL_DBUS_SET_STRING(p->start_tzid),
 356                         p->end.type, arg_end,
 357                         CAL_DBUS_SET_STRING(p->end_tzid),
 358                         p->is_allday);
 359         return value;
 360 }
 361
 362 static GVariant *_alarm_to_gvariant(calendar_record_h record)
 363 {
 364         GVariant *value = NULL;
 365         cal_alarm_s *p = (cal_alarm_s *)record;
 366         GVariant *arg_alarm = _caltime_to_gvariant(&p->alarm);
 367         value = g_variant_new("(iiiiissisiv)",
 368                         p->id, p->parent_id, p->is_deleted, p->remind_tick, p->remind_tick_unit,
 369                         CAL_DBUS_SET_STRING(p->alarm_description),
 370                         CAL_DBUS_SET_STRING(p->alarm_summary),
 371                         p->alarm_action,
 372                         CAL_DBUS_SET_STRING(p->alarm_attach),
 373                         p->alarm.type, arg_alarm);
 374         return value;
 375 }
 376
 377 static GVariant *_attendee_to_gvariant(calendar_record_h record)
 378 {
 379         GVariant *value = NULL;
 380         cal_attendee_s *p = (cal_attendee_s *)record;
 381         value = g_variant_new("(iisiisssiiissss)",
 382                         p->id, p->parent_id,
 383                         CAL_DBUS_SET_STRING(p->attendee_number),
 384                         p->attendee_cutype, p->attendee_ct_index,
 385                         CAL_DBUS_SET_STRING(p->attendee_uid),
 386                         CAL_DBUS_SET_STRING(p->attendee_group),
 387                         CAL_DBUS_SET_STRING(p->attendee_email),
 388                         p->attendee_role, p->attendee_status, p->attendee_rsvp,
 389                         CAL_DBUS_SET_STRING(p->attendee_delegatee_uri),
 390                         CAL_DBUS_SET_STRING(p->attendee_delegator_uri),
 391                         CAL_DBUS_SET_STRING(p->attendee_name),
 392                         CAL_DBUS_SET_STRING(p->attendee_member));
 393         return value;
 394 }
 395
 396 static GVariant *_timezone_to_gvariant(calendar_record_h record)
 397 {
 398         GVariant *value = NULL;
 399         cal_timezone_s *p = (cal_timezone_s *)record;
 400         value = g_variant_new("(iisiiiiisiiiiii)",
 401                         p->index, p->tz_offset_from_gmt,
 402                         CAL_DBUS_SET_STRING(p->standard_name),
 403                         p->std_start_month, p->std_start_position_of_week, p->std_start_day,
 404                         p->std_start_hour, p->standard_bias,
 405                         CAL_DBUS_SET_STRING(p->day_light_name),
 406                         p->day_light_start_month, p->day_light_start_position_of_week,
 407                         p->day_light_start_day, p->day_light_start_hour, p->day_light_bias,
 408                         p->calendar_id);
 409         return value;
 410 }
 411
 412 static GVariant *_extended_to_gvariant(calendar_record_h record)
 413 {
 414         GVariant *value = NULL;
 415         cal_extended_s *p = (cal_extended_s *)record;
 416         value = g_variant_new("(iiiss)",
 417                         p->id, p->record_id, p->record_type,
 418                         CAL_DBUS_SET_STRING(p->key),
 419                         CAL_DBUS_SET_STRING(p->value));
 420         return value;
 421 }
 422
 423 static GVariant *_event_to_gvariant(calendar_record_h record)
 424 {
 425         int i;
 426         RETV_IF(NULL == record, NULL);
 427
 428         GVariant *arg_only_event = _only_event_to_gvariant(record);
 429         if (NULL == arg_only_event) {
 430                 ERR("_only_event_to_gvariant() Fail");
 431                 return NULL;
 432         }
 433
 434         unsigned int count_alarm = 0;
 435         GVariantBuilder builder_alarm;
 436         g_variant_builder_init(&builder_alarm, G_VARIANT_TYPE("av"));
 437         calendar_record_get_child_record_count(record, _calendar_event.calendar_alarm, &count_alarm);
 438         if (0 < count_alarm) {
 439                 for (i = 0 ; i < count_alarm; i++) {
 440                         calendar_record_h alarm = NULL;
 441                         calendar_record_get_child_record_at_p(record, _calendar_event.calendar_alarm, i, &alarm);
 442                         g_variant_builder_add(&builder_alarm, "v", _alarm_to_gvariant(alarm));
 443                 }
 444         } else {
 445                 DBG("No alarm");
 446                 g_variant_builder_add(&builder_alarm, "v", cal_dbus_utils_null_to_gvariant());
 447         }
 448
 449         unsigned int count_attendee = 0;
 450         GVariantBuilder builder_attendee;
 451         g_variant_builder_init(&builder_attendee, G_VARIANT_TYPE("av"));
 452         calendar_record_get_child_record_count(record, _calendar_event.calendar_attendee, &count_attendee);
 453         if (0 < count_attendee) {
 454                 for (i = 0 ; i < count_attendee; i++) {
 455                         calendar_record_h attendee = NULL;
 456                         calendar_record_get_child_record_at_p(record, _calendar_event.calendar_attendee, i, &attendee);
 457                         g_variant_builder_add(&builder_attendee, "v", _attendee_to_gvariant(attendee));
 458                 }
 459         } else {
 460                 DBG("No attendee");
 461                 g_variant_builder_add(&builder_attendee, "v", cal_dbus_utils_null_to_gvariant());
 462         }
 463
 464         unsigned int count_exception = 0;
 465         GVariantBuilder builder_exception;
 466         g_variant_builder_init(&builder_exception, G_VARIANT_TYPE("av"));
 467         calendar_record_get_child_record_count(record, _calendar_event.exception, &count_exception);
 468         if (0 < count_exception) {
 469                 for (i = 0 ; i < count_exception; i++) {
 470                         calendar_record_h exception = NULL;
 471                         calendar_record_get_child_record_at_p(record, _calendar_event.exception, i, &exception);
 472                         g_variant_builder_add(&builder_exception, "v", _only_event_to_gvariant(exception));
 473                 }
 474         } else {
 475                 DBG("No exception");
 476                 g_variant_builder_add(&builder_exception, "v", cal_dbus_utils_null_to_gvariant());
 477         }
 478
 479         unsigned int count_extended = 0;
 480         GVariantBuilder builder_extended;
 481         g_variant_builder_init(&builder_extended, G_VARIANT_TYPE("av"));
 482         calendar_record_get_child_record_count(record, _calendar_event.extended, &count_extended);
 483         if (0 < count_extended) {
 484                 for (i = 0 ; i < count_extended; i++) {
 485                         calendar_record_h extended = NULL;
 486                         calendar_record_get_child_record_at_p(record, _calendar_event.extended, i, &extended);
 487                         g_variant_builder_add(&builder_extended, "v", _extended_to_gvariant(extended));
 488                 }
 489         } else {
 490                 DBG("No extended");
 491                 g_variant_builder_add(&builder_extended, "v", cal_dbus_utils_null_to_gvariant());
 492         }
 493
 494         GVariant *value = NULL;
 495         value = g_variant_new("(viaviaviaviav)", arg_only_event,
 496                         count_alarm, &builder_alarm, count_attendee, &builder_attendee,
 497                         count_exception, &builder_exception, count_extended, &builder_extended);
 498
 499         return value;
 500 }
 501
 502 static GVariant *_only_todo_to_gvariant(calendar_record_h record)
 503 {
 504         GVariant *value = NULL;
 505         RETV_IF(NULL == record, NULL);
 506
 507         cal_todo_s *p = (cal_todo_s *)record;
 508         GVariant *arg_until = _caltime_to_gvariant(&p->until);
 509         GVariant *arg_start = _caltime_to_gvariant(&p->start);
 510         GVariant *arg_due = _caltime_to_gvariant(&p->due);
 511
 512         value = g_variant_new("(iissssiiisddxxiixiiiviisssssssssiiiissssivsivsssii)",
 513                         p->index, p->calendar_id,
 514                         CAL_DBUS_SET_STRING(p->summary),
 515                         CAL_DBUS_SET_STRING(p->description),
 516                         CAL_DBUS_SET_STRING(p->location),
 517                         CAL_DBUS_SET_STRING(p->categories),
 518                         p->todo_status, p->priority, p->sensitivity,
 519                         CAL_DBUS_SET_STRING(p->uid),
 520                         p->latitude, p->longitude, p->created_time, p->completed_time, p->progress,
 521                         p->is_deleted, p->last_mod, p->freq, p->range_type, p->until.type,
 522                         arg_until, p->count, p->interval,
 523                         CAL_DBUS_SET_STRING(p->bysecond),
 524                         CAL_DBUS_SET_STRING(p->byminute),
 525                         CAL_DBUS_SET_STRING(p->byhour),
 526                         CAL_DBUS_SET_STRING(p->byday),
 527                         CAL_DBUS_SET_STRING(p->bymonthday),
 528                         CAL_DBUS_SET_STRING(p->byyearday),
 529                         CAL_DBUS_SET_STRING(p->byweekno),
 530                         CAL_DBUS_SET_STRING(p->bymonth),
 531                         CAL_DBUS_SET_STRING(p->bysetpos),
 532                         p->wkst, p->has_alarm, p->system_type, p->updated,
 533                         CAL_DBUS_SET_STRING(p->sync_data1),
 534                         CAL_DBUS_SET_STRING(p->sync_data2),
 535                         CAL_DBUS_SET_STRING(p->sync_data3),
 536                         CAL_DBUS_SET_STRING(p->sync_data4),
 537                         p->start.type, arg_start,
 538                         CAL_DBUS_SET_STRING(p->start_tzid),
 539                         p->due.type, arg_due,
 540                         CAL_DBUS_SET_STRING(p->due_tzid),
 541                         CAL_DBUS_SET_STRING(p->organizer_name),
 542                         CAL_DBUS_SET_STRING(p->organizer_email),
 543                         p->has_attendee, p->is_allday);
 544
 545         return value;
 546 }
 547
 548 static GVariant *_todo_to_gvariant(calendar_record_h record)
 549 {
 550         int i;
 551         RETV_IF(NULL == record, NULL);
 552
 553         GVariant *arg_only_todo = _only_todo_to_gvariant(record);
 554         if (NULL == arg_only_todo) {
 555                 ERR("_only_todo_to_gvariant() Fail");
 556                 return NULL;
 557         }
 558
 559         unsigned int count_alarm = 0;
 560         GVariantBuilder builder_alarm;
 561         g_variant_builder_init(&builder_alarm, G_VARIANT_TYPE("av"));
 562         calendar_record_get_child_record_count(record, _calendar_todo.calendar_alarm, &count_alarm);
 563         if (0 < count_alarm) {
 564                 for (i = 0 ; i < count_alarm; i++) {
 565                         calendar_record_h alarm = NULL;
 566                         calendar_record_get_child_record_at_p(record, _calendar_todo.calendar_alarm, i, &alarm);
 567                         g_variant_builder_add(&builder_alarm, "v", _alarm_to_gvariant(alarm));
 568                 }
 569         } else {
 570                 DBG("No alarm");
 571                 g_variant_builder_add(&builder_alarm, "v", cal_dbus_utils_null_to_gvariant());
 572         }
 573
 574         unsigned int count_attendee = 0;
 575         GVariantBuilder builder_attendee;
 576         g_variant_builder_init(&builder_attendee, G_VARIANT_TYPE("av"));
 577         calendar_record_get_child_record_count(record, _calendar_todo.calendar_attendee, &count_attendee);
 578         if (0 < count_attendee) {
 579                 for (i = 0 ; i < count_attendee; i++) {
 580                         calendar_record_h attendee = NULL;
 581                         calendar_record_get_child_record_at_p(record, _calendar_todo.calendar_attendee, i, &attendee);
 582                         g_variant_builder_add(&builder_attendee, "v", _attendee_to_gvariant(attendee));
 583                 }
 584         } else {
 585                 DBG("No attendee");
 586                 g_variant_builder_add(&builder_attendee, "v", cal_dbus_utils_null_to_gvariant());
 587         }
 588
 589         unsigned int count_extended = 0;
 590         GVariantBuilder builder_extended;
 591         g_variant_builder_init(&builder_extended, G_VARIANT_TYPE("av"));
 592         calendar_record_get_child_record_count(record, _calendar_todo.extended, &count_extended);
 593         if (0 < count_extended) {
 594                 for (i = 0 ; i < count_extended; i++) {
 595                         calendar_record_h extended = NULL;
 596                         calendar_record_get_child_record_at_p(record, _calendar_todo.extended, i, &extended);
 597                         g_variant_builder_add(&builder_extended, "v", _extended_to_gvariant(extended));
 598                 }
 599         } else {
 600                 DBG("No extended");
 601                 g_variant_builder_add(&builder_extended, "v", cal_dbus_utils_null_to_gvariant());
 602         }
 603
 604
 605         GVariant *value = NULL;
 606         value = g_variant_new("(viaviaviav)", arg_only_todo,
 607                         count_alarm, &builder_alarm, count_attendee, &builder_attendee,
 608                         count_extended, &builder_extended);
 609
 610         return value;
 611 }
 612
 613 static GVariant *_instance_utime_to_gvariant(calendar_record_h record)
 614 {
 615         GVariant *value = NULL;
 616         cal_instance_utime_s *p = (cal_instance_utime_s *)record;
 617
 618         GVariant *arg_start = _caltime_to_gvariant(&p->start);
 619         GVariant *arg_end = _caltime_to_gvariant(&p->end);
 620
 621         value = g_variant_new("(iiivivsssiiiiiddiixs)",
 622                         p->event_id, p->calendar_id, p->start.type, arg_start, p->end.type, arg_end,
 623                         CAL_DBUS_SET_STRING(p->summary),
 624                         CAL_DBUS_SET_STRING(p->description),
 625                         CAL_DBUS_SET_STRING(p->location),
 626                         p->busy_status, p->event_status, p->priority, p->sensitivity, p->has_rrule,
 627                         p->latitude, p->longitude, p->has_alarm, p->original_event_id, p->last_mod,
 628                         CAL_DBUS_SET_STRING(p->sync_data1));
 629         return value;
 630 }
 631
 632 static GVariant *_instance_localtime_to_gvariant(calendar_record_h record)
 633 {
 634         GVariant *value = NULL;
 635         cal_instance_localtime_s *p = (cal_instance_localtime_s *)record;
 636
 637         GVariant *arg_start = _caltime_to_gvariant(&p->start);
 638         GVariant *arg_end = _caltime_to_gvariant(&p->end);
 639
 640         value = g_variant_new("(iiivivsssiiiiiddiixsi)",
 641                         p->event_id, p->calendar_id, p->start.type, arg_start, p->end.type, arg_end,
 642                         CAL_DBUS_SET_STRING(p->summary),
 643                         CAL_DBUS_SET_STRING(p->description),
 644                         CAL_DBUS_SET_STRING(p->location),
 645                         p->busy_status, p->event_status, p->priority, p->sensitivity, p->has_rrule,
 646                         p->latitude, p->longitude, p->has_alarm, p->original_event_id, p->last_mod,
 647                         CAL_DBUS_SET_STRING(p->sync_data1),
 648                         p->is_allday);
 649         return value;
 650 }
 651
 652 static GVariant *_instance_utime_extended_to_gvariant(calendar_record_h record)
 653 {
 654         GVariant *value = NULL;
 655         cal_instance_utime_extended_s *p = (cal_instance_utime_extended_s *)record;
 656
 657         GVariant *arg_start = _caltime_to_gvariant(&p->start);
 658         GVariant *arg_end = _caltime_to_gvariant(&p->end);
 659
 660         value = g_variant_new("(iiivivsssiiiiiddiixssissss)",
 661                         p->event_id, p->calendar_id, p->start.type, arg_start, p->end.type, arg_end,
 662                         CAL_DBUS_SET_STRING(p->summary),
 663                         CAL_DBUS_SET_STRING(p->description),
 664                         CAL_DBUS_SET_STRING(p->location),
 665                         p->busy_status, p->event_status, p->priority, p->sensitivity, p->has_rrule,
 666                         p->latitude, p->longitude, p->has_alarm, p->original_event_id, p->last_mod,
 667                         CAL_DBUS_SET_STRING(p->organizer_name),
 668                         CAL_DBUS_SET_STRING(p->categories),
 669                         p->has_attendee,
 670                         CAL_DBUS_SET_STRING(p->sync_data1),
 671                         CAL_DBUS_SET_STRING(p->sync_data2),
 672                         CAL_DBUS_SET_STRING(p->sync_data3),
 673                         CAL_DBUS_SET_STRING(p->sync_data4));
 674         return value;
 675 }
 676
 677 static GVariant *_instance_localtime_extended_to_gvariant(calendar_record_h record)
 678 {
 679         GVariant *value = NULL;
 680         cal_instance_localtime_extended_s *p = (cal_instance_localtime_extended_s *)record;
 681
 682         GVariant *arg_start = _caltime_to_gvariant(&p->start);
 683         GVariant *arg_end = _caltime_to_gvariant(&p->end);
 684
 685         value = g_variant_new("(iiivivsssiiiiiddiixssissss)",
 686                         p->event_id, p->calendar_id, p->start.type, arg_start, p->end.type, arg_end,
 687                         CAL_DBUS_SET_STRING(p->summary),
 688                         CAL_DBUS_SET_STRING(p->description),
 689                         CAL_DBUS_SET_STRING(p->location),
 690                         p->busy_status, p->event_status,
 691                         p->priority, p->sensitivity, p->has_rrule, p->latitude, p->longitude,
 692                         p->has_alarm, p->original_event_id, p->last_mod,
 693                         CAL_DBUS_SET_STRING(p->organizer_name),
 694                         CAL_DBUS_SET_STRING(p->categories),
 695                         p->has_attendee,
 696                         CAL_DBUS_SET_STRING(p->sync_data1),
 697                         CAL_DBUS_SET_STRING(p->sync_data2),
 698                         CAL_DBUS_SET_STRING(p->sync_data3),
 699                         CAL_DBUS_SET_STRING(p->sync_data4));
 700         return value;
 701 }
 702
 703 static GVariant *_updated_info_to_gvariant(calendar_record_h record)
 704 {
 705         GVariant *value = NULL;
 706         cal_updated_info_s *p = (cal_updated_info_s *)record;
 707         value = g_variant_new("(iiii)", p->type, p->id, p->calendar_id, p->version);
 708         return value;
 709 }
 710
 711 static GVariant *_value_to_gvariant(cal_search_value_s *p)
 712 {
 713         GVariant *value = NULL;
 714
 715         int type = p->property_id & CAL_PROPERTY_DATA_TYPE_MASK;
 716         switch (type) {
 717         case CAL_PROPERTY_DATA_TYPE_STR:
 718                 value = g_variant_new("s", CAL_DBUS_SET_STRING(p->value.s));
 719                 break;
 720         case CAL_PROPERTY_DATA_TYPE_INT:
 721                 value = g_variant_new("i", p->value.i);
 722                 break;
 723         case CAL_PROPERTY_DATA_TYPE_DOUBLE:
 724                 value = g_variant_new("d", p->value.d);
 725                 break;
 726         case CAL_PROPERTY_DATA_TYPE_LLI:
 727                 value = g_variant_new("x", p->value.lli);
 728                 break;
 729         case CAL_PROPERTY_DATA_TYPE_CALTIME:
 730                 value = g_variant_new("(iv)", p->value.caltime.type,
 731                                 _caltime_to_gvariant(&p->value.caltime));
 732                 break;
 733         default:
 734                 ERR("Invalid parameter(0x%x)", type);
 735                 break;
 736         }
 737         return value;
 738 }
 739
 740 static GVariant *_search_to_gvariant(calendar_record_h record)
 741 {
 742         cal_search_s *p = (cal_search_s *)record;
 743
 744         GVariant *arg_search = NULL;
 745         GVariantBuilder builder;
 746         g_variant_builder_init(&builder, (G_VARIANT_TYPE("a(iv)")));
 747         GVariant *arg_value = NULL;
 748         int count = g_slist_length(p->values);
 749
 750         if (0 < count) {
 751                 GSList *cursor = p->values;
 752                 while (cursor) {
 753                         cal_search_value_s * d = (cal_search_value_s *)(cursor->data);
 754                         arg_value = _value_to_gvariant(d);
 755                         g_variant_builder_add(&builder, "(iv)", d->property_id, arg_value);
 756                         cursor = g_slist_next(cursor);
 757                 }
 758         } else {
 759                 arg_value = cal_dbus_utils_null_to_gvariant();
 760                 g_variant_builder_add(&builder, "(iv)", 1, arg_value);
 761         }
 762         arg_search = g_variant_builder_end(&builder);
 763
 764         GVariant *value = NULL;
 765         value = g_variant_new("(isv)", count, p->common.view_uri, arg_search);
 766         return value;
 767 }
 768
 769 GVariant *cal_dbus_utils_record_to_gvariant(calendar_record_h record)
 770 {
 771         int type = 0;
 772         GVariant *value = NULL;
 773         GVariant *arg_common = NULL;
 774         GVariant *arg_record = NULL;
 775
 776         if (NULL == record) {
 777                 ERR("record is NULL");
 778                 arg_common = cal_dbus_utils_null_to_gvariant();
 779                 type = -1;
 780         } else {
 781                 cal_record_s *rec = (cal_record_s *)record;
 782                 arg_common = cal_dbus_utils_common_to_gvariant(rec);
 783                 type = rec->type;
 784         }
 785
 786         switch (type) {
 787         case CAL_RECORD_TYPE_BOOK:
 788                 arg_record = _book_to_gvariant(record);
 789                 break;
 790         case CAL_RECORD_TYPE_EVENT:
 791                 arg_record = _event_to_gvariant(record);
 792                 break;
 793         case CAL_RECORD_TYPE_TODO:
 794                 arg_record = _todo_to_gvariant(record);
 795                 break;
 796         case CAL_RECORD_TYPE_ALARM:
 797                 arg_record = _alarm_to_gvariant(record);
 798                 break;
 799         case CAL_RECORD_TYPE_ATTENDEE:
 800                 arg_record = _attendee_to_gvariant(record);
 801                 break;
 802         case CAL_RECORD_TYPE_TIMEZONE:
 803                 arg_record = _timezone_to_gvariant(record);
 804                 break;
 805         case CAL_RECORD_TYPE_INSTANCE_UTIME:
 806                 arg_record = _instance_utime_to_gvariant(record);
 807                 break;
 808         case CAL_RECORD_TYPE_INSTANCE_LOCALTIME:
 809                 arg_record = _instance_localtime_to_gvariant(record);
 810                 break;
 811         case CAL_RECORD_TYPE_INSTANCE_UTIME_EXTENDED:
 812                 arg_record = _instance_utime_extended_to_gvariant(record);
 813                 break;
 814         case CAL_RECORD_TYPE_INSTANCE_LOCALTIME_EXTENDED:
 815                 arg_record = _instance_localtime_extended_to_gvariant(record);
 816                 break;
 817         case CAL_RECORD_TYPE_UPDATED_INFO:
 818                 arg_record = _updated_info_to_gvariant(record);
 819                 break;
 820         case CAL_RECORD_TYPE_SEARCH:
 821                 arg_record = _search_to_gvariant(record);
 822                 break;
 823         case CAL_RECORD_TYPE_EXTENDED:
 824                 arg_record = _extended_to_gvariant(record);
 825                 break;
 826         default:
 827                 ERR("Invalid type(%d)", type);
 828                 arg_record = cal_dbus_utils_null_to_gvariant();
 829                 break;
 830         }
 831         value = g_variant_new("(ivv)", type, arg_common, arg_record);
 832         return value;
 833 }
 834
 835 GVariant *cal_dbus_utils_list_to_gvariant(calendar_list_h list)
 836 {
 837         int has_list = 0;
 838         GVariant *value = NULL;
 839         GVariant *arg_list = NULL;
 840
 841         if (NULL == list) {
 842                 ERR("list is NULL");
 843                 has_list = 0;
 844                 arg_list = cal_dbus_utils_null_to_gvariant();
 845                 return g_variant_new("(iv)", has_list, arg_list);
 846         }
 847
 848         has_list = 1;
 849         GVariantBuilder builder;
 850         g_variant_builder_init(&builder, G_VARIANT_TYPE("av"));
 851
 852         int i;
 853         int count = 0;
 854         calendar_list_get_count(list, &count);
 855
 856         calendar_list_first(list);
 857         for (i = 0; i < count; i++) {
 858                 calendar_record_h record = NULL;
 859                 calendar_list_get_current_record_p(list, &record);
 860                 GVariant *arg_record = cal_dbus_utils_record_to_gvariant(record);
 861                 g_variant_builder_add(&builder, "v", arg_record);
 862                 calendar_list_next(list);
 863         }
 864         arg_list = g_variant_builder_end(&builder);
 865
 866         value = g_variant_new("(iv)", has_list, arg_list);
 867         return value;
 868 }
 869
 870 int cal_dbus_utils_gvariant_to_handle(GVariant *arg_handle, calendar_h *out_handle)
 871 {
 872         RETV_IF(NULL == arg_handle, CALENDAR_ERROR_INVALID_PARAMETER);
 873         RETV_IF(NULL == out_handle, CALENDAR_ERROR_INVALID_PARAMETER);
 874
 875         calendar_h handle = NULL;
 876         cal_handle_create(&handle);
 877         if (NULL == handle) {
 878                 ERR("handle is NULL");
 879                 return CALENDAR_ERROR_OUT_OF_MEMORY;
 880         }
 881         cal_s *p = (cal_s *)handle;
 882
 883         g_variant_get(arg_handle, "(ii)",
 884                         &p->version, &p->connection_count);
 885         *out_handle = handle;
 886         return CALENDAR_ERROR_NONE;
 887 }
 888
 889 static int _gvariant_to_book(GVariant *arg_record, calendar_record_h *out_record)
 890 {
 891         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
 892         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
 893
 894         calendar_record_h record = NULL;
 895         calendar_record_create(_calendar_book._uri, &record);
 896         cal_book_s *p = (cal_book_s *)record;
 897
 898         g_variant_get(arg_record, "(ii&si&s&s&s&siiii&s&s&s&si)",
 899                         &p->index, &p->store_type, &p->uid, &p->updated, &p->name, &p->description,
 900                         &p->color, &p->location, &p->visibility, &p->sync_event, &p->is_deleted,
 901                         &p->account_id, &p->sync_data1, &p->sync_data2, &p->sync_data3,
 902                         &p->sync_data4, &p->mode);
 903         CAL_DBUS_GET_STRING(p->uid);
 904         CAL_DBUS_GET_STRING(p->name);
 905         CAL_DBUS_GET_STRING(p->description);
 906         CAL_DBUS_GET_STRING(p->color);
 907         CAL_DBUS_GET_STRING(p->location);
 908         CAL_DBUS_GET_STRING(p->sync_data1);
 909         CAL_DBUS_GET_STRING(p->sync_data2);
 910         CAL_DBUS_GET_STRING(p->sync_data3);
 911         CAL_DBUS_GET_STRING(p->sync_data4);
 912
 913         *out_record = record;
 914         return CALENDAR_ERROR_NONE;
 915 }
 916
 917 static int _gvariant_to_alarm(GVariant * arg_record, calendar_record_h *out_record)
 918 {
 919         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
 920         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
 921
 922         calendar_record_h record = NULL;
 923         calendar_record_create(_calendar_alarm._uri, &record);
 924         GVariant *arg_alarm = NULL;
 925         cal_alarm_s *p = (cal_alarm_s *)record;
 926         g_variant_get(arg_record, "(iiiii&s&si&siv)",
 927                         &p->id, &p->parent_id, &p->is_deleted, &p->remind_tick, &p->remind_tick_unit,
 928                         &p->alarm_description, &p->alarm_summary, &p->alarm_action, &p->alarm_attach,
 929                         &p->alarm.type, &arg_alarm);
 930         _gvariant_to_caltime(p->alarm.type, arg_alarm, &p->alarm);
 931         CAL_DBUS_GET_STRING(p->alarm_description);
 932         CAL_DBUS_GET_STRING(p->alarm_summary);
 933         CAL_DBUS_GET_STRING(p->alarm_attach);
 934
 935         *out_record = record;
 936         return CALENDAR_ERROR_NONE;
 937 }
 938
 939 static int _gvariant_to_attendee(GVariant * arg_record, calendar_record_h *out_record)
 940 {
 941         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
 942         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
 943
 944         calendar_record_h record = NULL;
 945         calendar_record_create(_calendar_attendee._uri, &record);
 946         cal_attendee_s *p = (cal_attendee_s *)record;
 947         g_variant_get(arg_record, "(ii&sii&s&s&siii&s&s&s&s)",
 948                         &p->id, &p->parent_id, &p->attendee_number, &p->attendee_cutype,
 949                         &p->attendee_ct_index, &p->attendee_uid, &p->attendee_group,
 950                         &p->attendee_email, &p->attendee_role, &p->attendee_status,
 951                         &p->attendee_rsvp, &p->attendee_delegatee_uri, &p->attendee_delegator_uri,
 952                         &p->attendee_name, &p->attendee_member);
 953         CAL_DBUS_GET_STRING(p->attendee_number);
 954         CAL_DBUS_GET_STRING(p->attendee_uid);
 955         CAL_DBUS_GET_STRING(p->attendee_group);
 956         CAL_DBUS_GET_STRING(p->attendee_email);
 957         CAL_DBUS_GET_STRING(p->attendee_delegatee_uri);
 958         CAL_DBUS_GET_STRING(p->attendee_delegator_uri);
 959         CAL_DBUS_GET_STRING(p->attendee_name);
 960         CAL_DBUS_GET_STRING(p->attendee_member);
 961
 962         *out_record = record;
 963         return CALENDAR_ERROR_NONE;
 964 }
 965
 966 static int _gvariant_to_timezone(GVariant * arg_record, calendar_record_h *out_record)
 967 {
 968         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
 969         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
 970
 971         calendar_record_h record = NULL;
 972         calendar_record_create(_calendar_timezone._uri, &record);
 973         cal_timezone_s *p = (cal_timezone_s *)record;
 974         g_variant_get(arg_record, "(ii&siiiii&siiiiii)",
 975                         &p->index, &p->tz_offset_from_gmt, &p->standard_name, &p->std_start_month,
 976                         &p->std_start_position_of_week, &p->std_start_day, &p->std_start_hour,
 977                         &p->standard_bias, &p->day_light_name, &p->day_light_start_month,
 978                         &p->day_light_start_position_of_week, &p->day_light_start_day,
 979                         &p->day_light_start_hour, &p->day_light_bias, &p->calendar_id);
 980         CAL_DBUS_GET_STRING(p->standard_name);
 981         CAL_DBUS_GET_STRING(p->day_light_name);
 982
 983         *out_record = record;
 984         return CALENDAR_ERROR_NONE;
 985 }
 986
 987 static int _gvariant_to_only_event(GVariant *arg_record, calendar_record_h *out_record)
 988 {
 989         calendar_record_h record = NULL;
 990         calendar_record_create(_calendar_event._uri, &record);
 991         cal_event_s *p = (cal_event_s *)record;
 992
 993         GVariant *arg_until = NULL;
 994         GVariant *arg_start = NULL;
 995         GVariant *arg_end = NULL;
 996
 997         g_variant_get(arg_record, "(ii&s&s&s&s&siiiiiii&s&s&siddixixiiivii"
 998                         "&s&s&s&s&s&s&s&s&si&s&siiii&s&s&s&siv&siv&si)",
 999                         &p->index, &p->calendar_id, &p->summary, &p->description, &p->location,
1000                         &p->categories, &p->exdate, &p->event_status, &p->priority, &p->timezone,
1001                         &p->contact_id, &p->busy_status, &p->sensitivity, &p->meeting_status,
1002                         &p->uid, &p->organizer_name, &p->organizer_email, &p->original_event_id,
1003                         &p->latitude, &p->longitude, &p->email_id, &p->created_time, &p->is_deleted,
1004                         &p->last_mod, &p->freq, &p->range_type, &p->until.type, &arg_until,
1005                         &p->count, &p->interval, &p->bysecond, &p->byminute, &p->byhour, &p->byday,
1006                         &p->bymonthday, &p->byyearday, &p->byweekno, &p->bymonth, &p->bysetpos,
1007                         &p->wkst, &p->recurrence_id, &p->rdate, &p->has_attendee, &p->has_alarm,
1008                         &p->system_type, &p->updated, &p->sync_data1, &p->sync_data2, &p->sync_data3,
1009                         &p->sync_data4, &p->start.type, &arg_start, &p->start_tzid, &p->end.type,
1010                         &arg_end, &p->end_tzid, &p->is_allday);
1011         _gvariant_to_caltime(p->until.type, arg_until, &p->until);
1012         _gvariant_to_caltime(p->start.type, arg_start, &p->start);
1013         _gvariant_to_caltime(p->end.type, arg_end, &p->end);
1014         CAL_DBUS_GET_STRING(p->summary);
1015         CAL_DBUS_GET_STRING(p->description);
1016         CAL_DBUS_GET_STRING(p->location);
1017         CAL_DBUS_GET_STRING(p->categories);
1018         CAL_DBUS_GET_STRING(p->exdate);
1019         CAL_DBUS_GET_STRING(p->uid);
1020         CAL_DBUS_GET_STRING(p->organizer_name);
1021         CAL_DBUS_GET_STRING(p->organizer_email);
1022         CAL_DBUS_GET_STRING(p->bysecond);
1023         CAL_DBUS_GET_STRING(p->byminute);
1024         CAL_DBUS_GET_STRING(p->byhour);
1025         CAL_DBUS_GET_STRING(p->byday);
1026         CAL_DBUS_GET_STRING(p->bymonthday);
1027         CAL_DBUS_GET_STRING(p->byyearday);
1028         CAL_DBUS_GET_STRING(p->byweekno);
1029         CAL_DBUS_GET_STRING(p->bymonth);
1030         CAL_DBUS_GET_STRING(p->bysetpos);
1031         CAL_DBUS_GET_STRING(p->recurrence_id);
1032         CAL_DBUS_GET_STRING(p->rdate);
1033         CAL_DBUS_GET_STRING(p->sync_data1);
1034         CAL_DBUS_GET_STRING(p->sync_data2);
1035         CAL_DBUS_GET_STRING(p->sync_data3);
1036         CAL_DBUS_GET_STRING(p->sync_data4);
1037         CAL_DBUS_GET_STRING(p->start_tzid);
1038         CAL_DBUS_GET_STRING(p->end_tzid);
1039
1040         *out_record = record;
1041         return CALENDAR_ERROR_NONE;
1042 }
1043
1044 static int _gvariant_to_value(GVariant *arg_value, cal_search_value_s *p)
1045 {
1046         int type = p->property_id & CAL_PROPERTY_DATA_TYPE_MASK;
1047         GVariant *arg_caltime = NULL;
1048         switch (type) {
1049         case CAL_PROPERTY_DATA_TYPE_STR:
1050                 g_variant_get(arg_value, "&s", &p->value.s);
1051                 CAL_DBUS_GET_STRING(p->value.s);
1052                 break;
1053         case CAL_PROPERTY_DATA_TYPE_INT:
1054                 g_variant_get(arg_value, "i", &p->value.i);
1055                 break;
1056         case CAL_PROPERTY_DATA_TYPE_DOUBLE:
1057                 g_variant_get(arg_value, "d", &p->value.d);
1058                 break;
1059         case CAL_PROPERTY_DATA_TYPE_LLI:
1060                 g_variant_get(arg_value, "x", &p->value.lli);
1061                 break;
1062         case CAL_PROPERTY_DATA_TYPE_CALTIME:
1063                 g_variant_get(arg_value, "(iv)", &p->value.caltime.type, arg_caltime);
1064                 _gvariant_to_caltime(p->value.caltime.type, arg_caltime, &p->value.caltime);
1065                 break;
1066         default:
1067                 ERR("Invalid parameter(0x%x)", type);
1068                 break;
1069         }
1070         return CALENDAR_ERROR_NONE;
1071 }
1072
1073 static int _gvariant_to_search(GVariant *arg_record, calendar_record_h *out_record)
1074 {
1075         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1076         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1077
1078         int count = 0;
1079         char *view_uri = NULL;
1080         GVariant *arg_search = NULL;
1081         g_variant_get(arg_record, "(i&sv)", &count, &view_uri, &arg_search);
1082
1083         calendar_record_h record = NULL;
1084         calendar_record_create(view_uri, &record);
1085         cal_search_s *p = (cal_search_s *)record;
1086
1087         GVariantIter *iter_search = NULL;
1088         g_variant_get(arg_search, "a(iv)", &iter_search);
1089         int i;
1090         for (i = 0; i < count; i++) {
1091                 cal_search_value_s *value = calloc(1, sizeof(cal_search_value_s));
1092                 if (NULL == value) {
1093                         ERR("calloc() Fail");
1094                         break;
1095                 }
1096                 GVariant *arg_value = NULL;
1097                 g_variant_iter_loop(iter_search, "(iv)", &value->property_id, &arg_value);
1098                 _gvariant_to_value(arg_value, value);
1099                 p->values = g_slist_append(p->values, value);
1100         }
1101
1102         *out_record = record;
1103         return CALENDAR_ERROR_NONE;
1104 }
1105
1106 static int _gvariant_to_extended(GVariant * arg_record, calendar_record_h *out_record)
1107 {
1108         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1109         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1110
1111         calendar_record_h record = NULL;
1112         calendar_record_create(_calendar_extended_property._uri, &record);
1113         cal_extended_s *p = (cal_extended_s *)record;
1114         g_variant_get(arg_record, "(iii&s&s)",
1115                         &p->id, &p->record_id, &p->record_type, &p->key, &p->value);
1116         CAL_DBUS_GET_STRING(p->key);
1117         CAL_DBUS_GET_STRING(p->value);
1118
1119         *out_record = record;
1120         return CALENDAR_ERROR_NONE;
1121 }
1122
1123 static void _free_composite_filter(cal_composite_filter_s* filter)
1124 {
1125         if (NULL == filter)
1126                 return;
1127         if (NULL == filter->filters)
1128                 return;
1129
1130         GSList *cursor = filter->filters;
1131         while (cursor) {
1132                 cal_filter_s *child_filter = (cal_filter_s*)cursor->data;
1133                 if (NULL == child_filter) {
1134                         cursor = g_slist_next(cursor);
1135                         continue;
1136                 }
1137                 if (CAL_FILTER_COMPOSITE == child_filter->filter_type) {
1138                         _free_composite_filter((cal_composite_filter_s *)child_filter);
1139                 } else {
1140                         cal_attribute_filter_s *attr = (cal_attribute_filter_s *)child_filter;
1141                         if (CAL_FILTER_STR == attr->filter_type)
1142                                 free(attr->value.s);
1143                 }
1144                 cursor = g_slist_next(cursor);
1145         }
1146         g_slist_free_full(filter->filters, free);
1147
1148         if (filter->filter_ops)
1149                 g_slist_free(filter->filter_ops);
1150
1151         free(filter->view_uri);
1152 }
1153
1154 static void _get_attribute_filter(GVariantIter *iter_filter, cal_filter_type_e filter_type,
1155                 cal_attribute_filter_s* filter)
1156 {
1157         RET_IF(NULL == filter);
1158
1159         GVariant *arg_caltime = NULL;
1160         filter->filter_type = filter_type;
1161
1162         GVariant *arg_value = NULL;
1163         g_variant_iter_loop(iter_filter, "v", &arg_value);
1164         g_variant_get(arg_value, "i", &filter->property_id);
1165         g_variant_iter_loop(iter_filter, "v", &arg_value);
1166         g_variant_get(arg_value, "i", &filter->match);
1167         g_variant_iter_loop(iter_filter, "v", &arg_value);
1168         switch (filter_type) {
1169         case CAL_FILTER_STR:
1170                 g_variant_get(arg_value, "&s", &filter->value.s);
1171                 CAL_DBUS_GET_STRING(filter->value.s);
1172                 break;
1173         case CAL_FILTER_INT:
1174                 g_variant_get(arg_value, "i", &filter->value.i);
1175                 break;
1176         case CAL_FILTER_DOUBLE:
1177                 g_variant_get(arg_value, "d", &filter->value.d);
1178                 break;
1179         case CAL_FILTER_LLI:
1180                 g_variant_get(arg_value, "x", &filter->value.lli);
1181                 break;
1182         case CAL_FILTER_CALTIME:
1183                 g_variant_get(arg_value, "(iv)", &filter->value.caltime.type, &arg_caltime);
1184                 _gvariant_to_caltime(filter->value.caltime.type, arg_caltime, &filter->value.caltime);
1185                 break;
1186         default:
1187                 ERR("Invalid filter_type(%d)", filter_type);
1188                 break;
1189         }
1190 }
1191
1192 static int _get_composite_filter(GVariantIter *iter_filter, cal_composite_filter_s* filter)
1193 {
1194         RETV_IF(NULL == filter, CALENDAR_ERROR_INVALID_PARAMETER);
1195
1196         filter->filter_type = CAL_FILTER_COMPOSITE;
1197
1198         GVariant *arg_value = NULL;
1199         g_variant_iter_loop(iter_filter, "v", &arg_value);
1200         g_variant_get(arg_value, "&s", &filter->view_uri);
1201         CAL_DBUS_GET_STRING(filter->view_uri);
1202
1203         int filter_count = 0;
1204         g_variant_iter_loop(iter_filter, "v", &arg_value);
1205         g_variant_get(arg_value, "i", &filter_count);
1206         int i;
1207         for (i = 0; i < filter_count; i++) {
1208                 int filter_type = 0;
1209                 g_variant_iter_loop(iter_filter, "v", &arg_value);
1210                 g_variant_get(arg_value, "i", &filter_type);
1211                 if (CAL_FILTER_COMPOSITE == filter_type) {
1212                         cal_composite_filter_s* com_filter = NULL;
1213                         com_filter = calloc(1, sizeof(cal_composite_filter_s));
1214                         if (NULL == com_filter) {
1215                                 ERR("calloc() Fail");
1216                                 _free_composite_filter(filter);
1217                                 return CALENDAR_ERROR_OUT_OF_MEMORY;
1218                         }
1219                         _get_composite_filter(iter_filter, com_filter);
1220                         filter->filters = g_slist_append(filter->filters, com_filter);
1221                 } else {
1222                         cal_attribute_filter_s* attr_filter = NULL;
1223                         attr_filter = calloc(1, sizeof(cal_attribute_filter_s));
1224                         if (NULL == attr_filter) {
1225                                 ERR("calloc() Fail");
1226                                 _free_composite_filter(filter);
1227                                 return CALENDAR_ERROR_OUT_OF_MEMORY;
1228                         }
1229                         _get_attribute_filter(iter_filter, filter_type, attr_filter);
1230                         filter->filters = g_slist_append(filter->filters, attr_filter);
1231                 }
1232         }
1233         int ops_count = 0;
1234         g_variant_iter_loop(iter_filter, "v", &arg_value);
1235         g_variant_get(arg_value, "i", &ops_count);
1236         for (i = 0; i < ops_count; i++) {
1237                 calendar_filter_operator_e op = 0;
1238                 g_variant_iter_loop(iter_filter, "v", &arg_value);
1239                 g_variant_get(arg_value, "i", &op);
1240                 filter->filter_ops = g_slist_append(filter->filter_ops, (void*)op);
1241         }
1242
1243         filter->properties = (cal_property_info_s *)cal_view_get_property_info(filter->view_uri,
1244                         &filter->property_count);
1245         return CALENDAR_ERROR_NONE;
1246 }
1247
1248 static int _gvariant_to_filter(GVariant *arg_filter, cal_query_s *q)
1249 {
1250         calendar_filter_h filter = (calendar_filter_h)q->filter;
1251         calendar_filter_create(q->view_uri, &filter);
1252         q->filter = (cal_composite_filter_s*)filter;
1253
1254         GVariantIter *iter_filter = NULL;
1255         g_variant_get(arg_filter, "av", &iter_filter);
1256
1257         int count = 0;
1258         GVariant *arg_value = NULL;
1259         g_variant_iter_loop(iter_filter, "v", &arg_value);
1260         g_variant_get(arg_value, "i", &count);
1261         _get_composite_filter(iter_filter, q->filter);
1262
1263         return CALENDAR_ERROR_NONE;
1264 }
1265
1266 static int _gvariant_to_projection(int count_projection, GVariant *arg_projection, cal_query_s *q)
1267 {
1268         GVariantIter *iter_projection = NULL;
1269         g_variant_get(arg_projection, "au", &iter_projection);
1270
1271         q->projection = calloc(count_projection, sizeof(unsigned int));
1272         if (NULL == q->projection) {
1273                 ERR("calloc() Fail");
1274                 return CALENDAR_ERROR_OUT_OF_MEMORY;
1275         }
1276         int i = 0;
1277         for (i = 0; i < count_projection; i++)
1278                 g_variant_iter_loop(iter_projection, "u", &q->projection[i]);
1279
1280         q->projection_count = count_projection;
1281
1282         return CALENDAR_ERROR_NONE;
1283 }
1284
1285 int cal_dbus_utils_gvariant_to_query(GVariant *arg_query, calendar_query_h *out_query)
1286 {
1287         RETV_IF(NULL == arg_query, CALENDAR_ERROR_INVALID_PARAMETER);
1288         RETV_IF(NULL == out_query, CALENDAR_ERROR_INVALID_PARAMETER);
1289
1290         char *view_uri = NULL;
1291         int has_filter = 0;
1292         GVariant *arg_filter = NULL;
1293         int count_projection = 0;
1294         GVariant *arg_projection = NULL;
1295         int property_id = 0;
1296         int has_asc = 0;
1297         int has_distinct = 0;
1298
1299         g_variant_get(arg_query, "(&siviviii)",
1300                         &view_uri, &has_filter, &arg_filter, &count_projection, &arg_projection,
1301                         &property_id, &has_asc, &has_distinct);
1302
1303         calendar_query_h query = NULL;
1304         calendar_query_create(view_uri, &query);
1305
1306         cal_query_s *q = (cal_query_s *)query;
1307
1308         if (has_filter)
1309                 _gvariant_to_filter(arg_filter, q);
1310         else
1311                 q->filter = NULL;
1312
1313         if (count_projection)
1314                 _gvariant_to_projection(count_projection, arg_projection, q);
1315         else
1316                 q->projection = NULL;
1317
1318         q->sort_property_id = property_id;
1319         q->properties = (cal_property_info_s *)cal_view_get_property_info(view_uri,
1320                         &q->property_count);
1321         q->asc = has_asc;
1322         q->distinct = has_distinct;
1323
1324         *out_query = query;
1325
1326         return CALENDAR_ERROR_NONE;
1327 }
1328
1329 int cal_dbus_utils_gvariant_to_ids(GVariant *arg_ids, int count, int **out_ids)
1330 {
1331         GVariantIter *iter_ids = NULL;
1332         g_variant_get(arg_ids, "ai", &iter_ids);
1333
1334         int *ids = calloc(count, sizeof(int));
1335         if (NULL == ids) {
1336                 ERR("calloc() Fail");
1337                 return CALENDAR_ERROR_OUT_OF_MEMORY;
1338         }
1339         int i = 0;
1340         for (i = 0; i < count; i++)
1341                 g_variant_iter_loop(iter_ids, "i", &ids[i]);
1342
1343         *out_ids = ids;
1344         return CALENDAR_ERROR_NONE;
1345 }
1346
1347 static int _gvariant_to_event(GVariant * arg_record, calendar_record_h *out_record)
1348 {
1349         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1350         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1351
1352         GVariant *arg_only_event = NULL;
1353         int count_alarm = 0;
1354         GVariantIter *iter_alarm = NULL;
1355         int count_attendee = 0;
1356         GVariantIter *iter_attendee = NULL;
1357         int count_exception = 0;
1358         GVariantIter *iter_exception = NULL;
1359         int count_extended = 0;
1360         GVariantIter *iter_extended = NULL;
1361         g_variant_get(arg_record, "(viaviaviaviav)", &arg_only_event,
1362                         &count_alarm, &iter_alarm, &count_attendee, &iter_attendee,
1363                         &count_exception, &iter_exception, &count_extended, &iter_extended);
1364
1365         calendar_record_h record = NULL;
1366         _gvariant_to_only_event(arg_only_event, &record);
1367
1368         if (0 < count_alarm) {
1369                 GVariant *arg_alarm = NULL;
1370                 while (g_variant_iter_loop(iter_alarm, "v", &arg_alarm)) {
1371                         calendar_record_h alarm = NULL;
1372                         _gvariant_to_alarm(arg_alarm, &alarm);
1373                         calendar_record_add_child_record(record, _calendar_event.calendar_alarm, alarm);
1374                 }
1375         } else {
1376                 DBG("No alarm");
1377         }
1378
1379         if (0 < count_attendee) {
1380                 GVariant *arg_attendee = NULL;
1381                 while (g_variant_iter_loop(iter_attendee, "v", &arg_attendee)) {
1382                         calendar_record_h attendee = NULL;
1383                         _gvariant_to_attendee(arg_attendee, &attendee);
1384                         calendar_record_add_child_record(record, _calendar_event.calendar_attendee, attendee);
1385                 }
1386         } else {
1387                 DBG("No attendee");
1388         }
1389
1390         if (0 < count_exception) {
1391                 GVariant *arg_exception = NULL;
1392                 while (g_variant_iter_loop(iter_exception, "v", &arg_exception)) {
1393                         calendar_record_h exception = NULL;
1394                         _gvariant_to_only_event(arg_exception, &exception);
1395                         calendar_record_add_child_record(record, _calendar_event.exception, exception);
1396                 }
1397         } else {
1398                 DBG("No exception");
1399         }
1400
1401         if (0 < count_extended) {
1402                 GVariant *arg_extended = NULL;
1403                 while (g_variant_iter_loop(iter_extended, "v", &arg_extended)) {
1404                         calendar_record_h extended = NULL;
1405                         _gvariant_to_extended(arg_extended, &extended);
1406                         calendar_record_add_child_record(record, _calendar_event.extended, extended);
1407                 }
1408         } else {
1409                 DBG("No extended");
1410         }
1411
1412         *out_record = record;
1413         return CALENDAR_ERROR_NONE;
1414 }
1415
1416 static int _gvariant_to_only_todo(GVariant *arg_record, calendar_record_h *out_record)
1417 {
1418         calendar_record_h record = NULL;
1419         calendar_record_create(_calendar_todo._uri, &record);
1420         cal_todo_s *p = (cal_todo_s *)record;
1421
1422         GVariant *arg_until = NULL;
1423         GVariant *arg_start = NULL;
1424         GVariant *arg_due = NULL;
1425
1426         g_variant_get(arg_record, "(ii&s&s&s&siii&sddxxiixiiivii&s&s&s&s&s&s&s&s&si"
1427                         "iii&s&s&s&siv&siv&s&s&sii)",
1428                         &p->index, &p->calendar_id,
1429                         &p->summary, &p->description, &p->location, &p->categories, &p->todo_status,
1430                         &p->priority, &p->sensitivity, &p->uid, &p->latitude, &p->longitude,
1431                         &p->created_time, &p->completed_time, &p->progress, &p->is_deleted,
1432                         &p->last_mod, &p->freq, &p->range_type, &p->until.type, &arg_until,
1433                         &p->count, &p->interval, &p->bysecond, &p->byminute, &p->byhour, &p->byday,
1434                         &p->bymonthday, &p->byyearday, &p->byweekno, &p->bymonth, &p->bysetpos,
1435                         &p->wkst, &p->has_alarm, &p->system_type, &p->updated, &p->sync_data1,
1436                         &p->sync_data2, &p->sync_data3, &p->sync_data4, &p->start.type, &arg_start,
1437                         &p->start_tzid, &p->due.type, &arg_due, &p->due_tzid, &p->organizer_name,
1438                         &p->organizer_email, &p->has_attendee, &p->is_allday);
1439         _gvariant_to_caltime(p->until.type, arg_until, &p->until);
1440         _gvariant_to_caltime(p->start.type, arg_start, &p->start);
1441         _gvariant_to_caltime(p->due.type, arg_due, &p->due);
1442         CAL_DBUS_GET_STRING(p->summary);
1443         CAL_DBUS_GET_STRING(p->description);
1444         CAL_DBUS_GET_STRING(p->location);
1445         CAL_DBUS_GET_STRING(p->categories);
1446         CAL_DBUS_GET_STRING(p->uid);
1447         CAL_DBUS_GET_STRING(p->bysecond);
1448         CAL_DBUS_GET_STRING(p->byminute);
1449         CAL_DBUS_GET_STRING(p->byhour);
1450         CAL_DBUS_GET_STRING(p->byday);
1451         CAL_DBUS_GET_STRING(p->bymonthday);
1452         CAL_DBUS_GET_STRING(p->byyearday);
1453         CAL_DBUS_GET_STRING(p->byweekno);
1454         CAL_DBUS_GET_STRING(p->bymonth);
1455         CAL_DBUS_GET_STRING(p->bysetpos);
1456         CAL_DBUS_GET_STRING(p->sync_data1);
1457         CAL_DBUS_GET_STRING(p->sync_data2);
1458         CAL_DBUS_GET_STRING(p->sync_data3);
1459         CAL_DBUS_GET_STRING(p->sync_data4);
1460         CAL_DBUS_GET_STRING(p->start_tzid);
1461         CAL_DBUS_GET_STRING(p->due_tzid);
1462         CAL_DBUS_GET_STRING(p->organizer_name);
1463         CAL_DBUS_GET_STRING(p->organizer_email);
1464
1465         *out_record = record;
1466         return CALENDAR_ERROR_NONE;
1467 }
1468
1469 static int _gvariant_to_todo(GVariant * arg_record, calendar_record_h *out_record)
1470 {
1471         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1472         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1473
1474         GVariant *arg_only_todo = NULL;
1475         int count_alarm = 0;
1476         GVariantIter *iter_alarm = NULL;
1477         int count_attendee = 0;
1478         GVariantIter *iter_attendee = NULL;
1479         int count_extended = 0;
1480         GVariantIter *iter_extended = NULL;
1481         g_variant_get(arg_record, "(viaviaviav)", &arg_only_todo,
1482                         &count_alarm, &iter_alarm, &count_attendee, &iter_attendee,
1483                         &count_extended, &iter_extended);
1484
1485         calendar_record_h record = NULL;
1486         _gvariant_to_only_todo(arg_only_todo, &record);
1487
1488         if (0 < count_alarm) {
1489                 GVariant *arg_alarm = NULL;
1490                 while (g_variant_iter_loop(iter_alarm, "v", &arg_alarm)) {
1491                         calendar_record_h alarm = NULL;
1492                         _gvariant_to_alarm(arg_alarm, &alarm);
1493                         calendar_record_add_child_record(record, _calendar_todo.calendar_alarm, alarm);
1494                 }
1495         } else {
1496                 DBG("No alarm");
1497         }
1498
1499         if (0 < count_attendee) {
1500                 GVariant *arg_attendee = NULL;
1501                 while (g_variant_iter_loop(iter_attendee, "v", &arg_attendee)) {
1502                         calendar_record_h attendee = NULL;
1503                         _gvariant_to_attendee(arg_attendee, &attendee);
1504                         calendar_record_add_child_record(record, _calendar_todo.calendar_attendee, attendee);
1505                 }
1506         } else {
1507                 DBG("No attendee");
1508         }
1509
1510         if (0 < count_extended) {
1511                 GVariant *arg_extended = NULL;
1512                 while (g_variant_iter_loop(iter_extended, "v", &arg_extended)) {
1513                         calendar_record_h extended = NULL;
1514                         _gvariant_to_extended(arg_extended, &extended);
1515                         calendar_record_add_child_record(record, _calendar_todo.extended, extended);
1516                 }
1517         } else {
1518                 DBG("No extended");
1519         }
1520         *out_record = record;
1521
1522         return CALENDAR_ERROR_NONE;
1523 }
1524
1525
1526 static int _gvariant_to_instance_utime(GVariant * arg_record, calendar_record_h *out_record)
1527 {
1528         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1529         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1530
1531         calendar_record_h record = NULL;
1532         calendar_record_create(_calendar_instance_utime_calendar_book._uri, &record);
1533         GVariant *arg_start = NULL;
1534         GVariant *arg_end = NULL;
1535         cal_instance_utime_s *p = (cal_instance_utime_s *)record;
1536         g_variant_get(arg_record, "(iiiviv&s&s&siiiiiddiix&s)",
1537                         &p->event_id, &p->calendar_id, &p->start.type, &arg_start, &p->end.type,
1538                         &arg_end, &p->summary, &p->description, &p->location, &p->busy_status,
1539                         &p->event_status, &p->priority, &p->sensitivity, &p->has_rrule, &p->latitude,
1540                         &p->longitude, &p->has_alarm, &p->original_event_id, &p->last_mod,
1541                         &p->sync_data1);
1542         _gvariant_to_caltime(p->start.type, arg_start, &p->start);
1543         _gvariant_to_caltime(p->end.type, arg_end, &p->end);
1544         CAL_DBUS_GET_STRING(p->summary);
1545         CAL_DBUS_GET_STRING(p->description);
1546         CAL_DBUS_GET_STRING(p->location);
1547         CAL_DBUS_GET_STRING(p->sync_data1);
1548
1549         *out_record = record;
1550         return CALENDAR_ERROR_NONE;
1551 }
1552
1553 static int _gvariant_to_instance_localtime(GVariant * arg_record, calendar_record_h *out_record)
1554 {
1555         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1556         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1557
1558         calendar_record_h record = NULL;
1559         calendar_record_create(_calendar_instance_localtime_calendar_book._uri, &record);
1560         GVariant *arg_start = NULL;
1561         GVariant *arg_end = NULL;
1562         cal_instance_localtime_s *p = (cal_instance_localtime_s *)record;
1563         g_variant_get(arg_record, "(iiiviv&s&s&siiiiiddiix&si)",
1564                         &p->event_id, &p->calendar_id, &p->start.type, &arg_start, &p->end.type,
1565                         &arg_end, &p->summary, &p->description, &p->location, &p->busy_status,
1566                         &p->event_status, &p->priority, &p->sensitivity, &p->has_rrule, &p->latitude,
1567                         &p->longitude, &p->has_alarm, &p->original_event_id, &p->last_mod,
1568                         &p->sync_data1, &p->is_allday);
1569         _gvariant_to_caltime(p->start.type, arg_start, &p->start);
1570         _gvariant_to_caltime(p->end.type, arg_end, &p->end);
1571         CAL_DBUS_GET_STRING(p->summary);
1572         CAL_DBUS_GET_STRING(p->description);
1573         CAL_DBUS_GET_STRING(p->location);
1574         CAL_DBUS_GET_STRING(p->sync_data1);
1575
1576         *out_record = record;
1577         return CALENDAR_ERROR_NONE;
1578 }
1579
1580 static int _gvariant_to_instance_utime_extended(GVariant * arg_record, calendar_record_h *out_record)
1581 {
1582         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1583         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1584
1585         calendar_record_h record = NULL;
1586         calendar_record_create(_calendar_instance_utime_calendar_book_extended._uri, &record);
1587         GVariant *arg_start = NULL;
1588         GVariant *arg_end = NULL;
1589         cal_instance_utime_extended_s *p = (cal_instance_utime_extended_s *)record;
1590         g_variant_get(arg_record, "(iiiviv&s&s&siiiiiddiix&s&si&s&s&s&s)",
1591                         &p->event_id, &p->calendar_id, &p->start.type, &arg_start, &p->end.type,
1592                         &arg_end, &p->summary, &p->description, &p->location, &p->busy_status,
1593                         &p->event_status, &p->priority, &p->sensitivity, &p->has_rrule, &p->latitude,
1594                         &p->longitude, &p->has_alarm, &p->original_event_id, &p->last_mod,
1595                         &p->organizer_name, &p->categories, &p->has_attendee, &p->sync_data1,
1596                         &p->sync_data2, &p->sync_data3, &p->sync_data4);
1597         _gvariant_to_caltime(p->start.type, arg_start, &p->start);
1598         _gvariant_to_caltime(p->end.type, arg_end, &p->end);
1599         CAL_DBUS_GET_STRING(p->summary);
1600         CAL_DBUS_GET_STRING(p->description);
1601         CAL_DBUS_GET_STRING(p->location);
1602         CAL_DBUS_GET_STRING(p->organizer_name);
1603         CAL_DBUS_GET_STRING(p->categories);
1604         CAL_DBUS_GET_STRING(p->sync_data1);
1605         CAL_DBUS_GET_STRING(p->sync_data2);
1606         CAL_DBUS_GET_STRING(p->sync_data3);
1607         CAL_DBUS_GET_STRING(p->sync_data4);
1608
1609         *out_record = record;
1610         return CALENDAR_ERROR_NONE;
1611 }
1612
1613 static int _gvariant_to_instance_localtime_extended(GVariant * arg_record, calendar_record_h *out_record)
1614 {
1615         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1616         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1617
1618         calendar_record_h record = NULL;
1619         calendar_record_create(_calendar_instance_localtime_calendar_book_extended._uri, &record);
1620         GVariant *arg_start = NULL;
1621         GVariant *arg_end = NULL;
1622         cal_instance_localtime_extended_s *p = (cal_instance_localtime_extended_s *)record;
1623         g_variant_get(arg_record, "(iiiviv&s&s&siiiiiddiix&s&si&s&s&s&s)",
1624                         &p->event_id, &p->calendar_id, &p->start.type, &arg_start, &p->end.type,
1625                         &arg_end, &p->summary, &p->description, &p->location, &p->busy_status,
1626                         &p->event_status, &p->priority, &p->sensitivity, &p->has_rrule, &p->latitude,
1627                         &p->longitude, &p->has_alarm, &p->original_event_id, &p->last_mod,
1628                         &p->organizer_name, &p->categories, &p->has_attendee, &p->sync_data1,
1629                         &p->sync_data2, &p->sync_data3, &p->sync_data4);
1630         _gvariant_to_caltime(p->start.type, arg_start, &p->start);
1631         _gvariant_to_caltime(p->end.type, arg_end, &p->end);
1632         CAL_DBUS_GET_STRING(p->summary);
1633         CAL_DBUS_GET_STRING(p->description);
1634         CAL_DBUS_GET_STRING(p->location);
1635         CAL_DBUS_GET_STRING(p->organizer_name);
1636         CAL_DBUS_GET_STRING(p->categories);
1637         CAL_DBUS_GET_STRING(p->sync_data1);
1638         CAL_DBUS_GET_STRING(p->sync_data2);
1639         CAL_DBUS_GET_STRING(p->sync_data3);
1640         CAL_DBUS_GET_STRING(p->sync_data4);
1641
1642         *out_record = record;
1643         return CALENDAR_ERROR_NONE;
1644 }
1645
1646 static int _gvariant_to_updated_info(GVariant * arg_record, calendar_record_h *out_record)
1647 {
1648         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1649         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1650
1651         calendar_record_h record = NULL;
1652         calendar_record_create(_calendar_updated_info._uri, &record);
1653         cal_updated_info_s *p = (cal_updated_info_s *)record;
1654         g_variant_get(arg_record, "(iiii)", &p->type, &p->id, &p->calendar_id, &p->version);
1655         *out_record = record;
1656         return CALENDAR_ERROR_NONE;
1657 }
1658
1659 static int _gvariant_to_record(int type, GVariant *arg_common, GVariant *arg_record, calendar_record_h *out_record)
1660 {
1661         RETV_IF(NULL == arg_record, CALENDAR_ERROR_INVALID_PARAMETER);
1662         RETV_IF(NULL == out_record, CALENDAR_ERROR_INVALID_PARAMETER);
1663
1664         calendar_record_h record = NULL;
1665         switch (type) {
1666         case CAL_RECORD_TYPE_BOOK:
1667                 _gvariant_to_book(arg_record, &record);
1668                 break;
1669         case CAL_RECORD_TYPE_EVENT:
1670                 _gvariant_to_event(arg_record, &record);
1671                 break;
1672         case CAL_RECORD_TYPE_TODO:
1673                 _gvariant_to_todo(arg_record, &record);
1674                 break;
1675         case CAL_RECORD_TYPE_ALARM:
1676                 _gvariant_to_alarm(arg_record, &record);
1677                 break;
1678         case CAL_RECORD_TYPE_ATTENDEE:
1679                 _gvariant_to_attendee(arg_record, &record);
1680                 break;
1681         case CAL_RECORD_TYPE_TIMEZONE:
1682                 _gvariant_to_timezone(arg_record, &record);
1683                 break;
1684         case CAL_RECORD_TYPE_INSTANCE_UTIME:
1685                 _gvariant_to_instance_utime(arg_record, &record);
1686                 break;
1687         case CAL_RECORD_TYPE_INSTANCE_LOCALTIME:
1688                 _gvariant_to_instance_localtime(arg_record, &record);
1689                 break;
1690         case CAL_RECORD_TYPE_INSTANCE_UTIME_EXTENDED:
1691                 _gvariant_to_instance_utime_extended(arg_record, &record);
1692                 break;
1693         case CAL_RECORD_TYPE_INSTANCE_LOCALTIME_EXTENDED:
1694                 _gvariant_to_instance_localtime_extended(arg_record, &record);
1695                 break;
1696         case CAL_RECORD_TYPE_UPDATED_INFO:
1697                 _gvariant_to_updated_info(arg_record, &record);
1698                 break;
1699         case CAL_RECORD_TYPE_SEARCH:
1700                 _gvariant_to_search(arg_record, &record);
1701                 break;
1702         case CAL_RECORD_TYPE_EXTENDED:
1703                 _gvariant_to_extended(arg_record, &record);
1704                 break;
1705         default:
1706                 ERR("Invalid type(%d)", type);
1707                 break;
1708         }
1709         if (-1 != type)
1710                 cal_dbus_utils_gvariant_to_common(arg_common, &record);
1711         *out_record = record;
1712         return CALENDAR_ERROR_NONE;
1713 }
1714
1715 int cal_dbus_utils_gvariant_to_record(GVariant *arg_record_pack, calendar_record_h *out_record)
1716 {
1717         int type = 0;
1718         GVariant *arg_common = NULL;
1719         GVariant *arg_record = NULL;
1720         g_variant_get(arg_record_pack, "(ivv)", &type, &arg_common, &arg_record);
1721         _gvariant_to_record(type, arg_common, arg_record, out_record);
1722         return CALENDAR_ERROR_NONE;
1723 }
1724
1725 int cal_dbus_utils_gvariant_to_list(GVariant *arg_list_pack, calendar_list_h *out_list)
1726 {
1727         int has_list = 0;
1728         GVariant *arg_list = NULL;
1729         g_variant_get(arg_list_pack, "(iv)", &has_list, &arg_list);
1730
1731         calendar_list_h l = NULL;
1732         calendar_list_create(&l);
1733
1734         if (1 == has_list) {
1735                 GVariantIter *iter_value = NULL;
1736                 g_variant_get(arg_list, "av", &iter_value);
1737
1738                 GVariant *arg_record = NULL;
1739                 while (g_variant_iter_loop(iter_value, "v", &arg_record)) {
1740                         calendar_record_h record = NULL;
1741                         cal_dbus_utils_gvariant_to_record(arg_record, &record);
1742                         calendar_list_add(l, record);
1743                 }
1744         }
1745         *out_list = l;
1746
1747         return CALENDAR_ERROR_NONE;
1748 }
1749
1750 GVariant *cal_dbus_utils_stream_to_gvariant(int stream_size, char *stream)
1751 {
1752         return g_variant_new("(is)", stream_size, CAL_DBUS_SET_STRING(stream));
1753 }
1754
1755 int cal_dbus_utils_gvariant_to_stream(GVariant *arg_stream, int *out_size, char **out_stream)
1756 {
1757         int size = 0;
1758         char *stream = NULL;
1759
1760         RETV_IF(NULL == out_size, CALENDAR_ERROR_INVALID_PARAMETER);
1761         RETV_IF(NULL == out_stream, CALENDAR_ERROR_INVALID_PARAMETER);
1762
1763         g_variant_get(arg_stream, "(i&s)", &size, &stream);
1764         CAL_DBUS_GET_STRING(stream);
1765         *out_size = size;
1766         *out_stream = cal_strdup(stream);
1767         return CALENDAR_ERROR_NONE;
1768 }