src/FScl_CalEventImpl.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16 /**
  17  * @file                FScl_CalEventImpl.cpp
  18  * @brief               This is the implementation for _CalEventImpl class.
  19  *
  20  * This file contains definitions of @e _CalEventImpl class.
  21  */
  22
  23 #include <new>
  24 #include <string.h>
  25 #include <FApp_AppInfo.h>
  26 #include <FBaseColArrayList.h>
  27 #include <FBaseSysLog.h>
  28 #include <FBase_StringConverter.h>
  29 #include <FLclCalendar.h>
  30 #include <FLclGregorianCalendar.h>
  31 #include <FLclTimeZone.h>
  32 #include <FSclAttendee.h>
  33 #include <FSclCalEvent.h>
  34 #include <FSclRecord.h>
  35 #include <FSysSystemTime.h>
  36 #include "FScl_RecordImpl.h"
  37 #include "FScl_CalEventImpl.h"
  38 #include "FScl_RecurrenceImpl.h"
  39 #include "FScl_CalendarbookImpl.h"
  40 #include "FScl_CalendarbookDbConnector.h"
  41
  42 using namespace Tizen::App;
  43 using namespace Tizen::Base;
  44 using namespace Tizen::Base::Collection;
  45 using namespace Tizen::Base::Utility;
  46 using namespace Tizen::Locales;
  47 using namespace Tizen::System;
  48
  49 namespace Tizen { namespace Social
  50 {
  51
  52 static const int _DEFAULT_ADDED_HOUR = 1;
  53 static const int _INVALID_ATTENDEE_INDEX = -1;
  54
  55 static const int _TERM_LIMIT_DAILY = 1;
  56 static const int _TERM_LIMIT_WEEKLY = 7;
  57 static const int _TERM_LIMIT_MONTHLY = 31;
  58 static const int _TERM_LIMIT_YEARLY = 366;
  59 static const int _NUMBER_OF_DAYS_OF_WEEK = 7;
  60
  61 static const wchar_t* _EVENT_CATEGORY_APPOINTMENT_STRING = L"Appointment";
  62 static const wchar_t* _EVENT_CATEGORY_ANNIVERSARY_STRING = L"Anniversary";
  63
  64 static const wchar_t* _RECURRENCE_KEYWORD_SUNDAY = L"SU";
  65 static const wchar_t* _RECURRENCE_KEYWORD_MONDAY = L"MO";
  66 static const wchar_t* _RECURRENCE_KEYWORD_TUESDAY = L"TU";
  67 static const wchar_t* _RECURRENCE_KEYWORD_WEDNESDAY = L"WE";
  68 static const wchar_t* _RECURRENCE_KEYWORD_THURSDAY = L"TH";
  69 static const wchar_t* _RECURRENCE_KEYWORD_FRIDAY = L"FR";
  70 static const wchar_t* _RECURRENCE_KEYWORD_SATURDAY = L"SA";
  71
  72 static const wchar_t* _RECURRENCE_DELIMITER = L",";
  73 static const int _RECURRENCE_DELIMITER_LENGTH = 1;
  74 static const wchar_t _RECURRENCE_BY_DAY_CHAR_PLUS = L'+';
  75 static const wchar_t _RECURRENCE_BY_DAY_CHAR_MINUS = L'-';
  76 static const wchar_t _RECURRENCE_BY_DAY_CHAR_ONE = L'1';
  77 static const int _RECURRENCE_BY_DAY_FIRST_INDEX = 0;
  78 static const int _RECURRENCE_BY_DAY_SECOND_INDEX = 1;
  79 static const int _MAX_WEEK_OF_MONTH = 5;
  80
  81 static const double _MIN_LATITUDE = -90.0;
  82 static const double _MAX_LATITUDE = 90.0;
  83 static const double _MIN_LONGITUDE = -180.0;
  84 static const double _MAX_LONGITUDE = 180.0;
  85
  86 _CalEventImpl::_CalEventImpl(void)
  87         : __originalEventId(INVALID_RECORD_ID)
  88         , __isInstance(false)
  89         , __reminderListUpdated(false)
  90 {
  91         // Set default start and end time
  92         DateTime startTime;
  93         SystemTime::GetCurrentTime(startTime);
  94         if (IsFailed(GetLastResult()))
  95         {
  96                 startTime = _CalendarbookImpl::GetMinDateTime();
  97                 ClearLastResult();
  98         }
  99
 100         DateTime endTime(startTime);
 101         result r = endTime.AddHours(_DEFAULT_ADDED_HOUR);
 102         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 103
 104         calendar_time_s startCalendarTime;
 105         calendar_time_s endCalendarTime;
 106         startCalendarTime.type = CALENDAR_TIME_UTIME;
 107         endCalendarTime.type = CALENDAR_TIME_UTIME;
 108         startCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(startTime);
 109         endCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(endTime);
 110
 111         r = _CalendarbookDbConnector::Connect();
 112         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 113
 114         calendar_record_h eventHandle = null;
 115         int errorCode = calendar_record_create(_calendar_event._uri, &eventHandle);
 116         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 117
 118         __eventRecord.ResetHandle(eventHandle);
 119
 120         calendar_record_set_caltime(eventHandle, _calendar_event.start_time, startCalendarTime);
 121         calendar_record_set_caltime(eventHandle, _calendar_event.end_time, endCalendarTime);
 122
 123         // default value
 124         calendar_record_set_int(eventHandle, _calendar_event.event_status, CALENDAR_EVENT_STATUS_NONE);
 125         calendar_record_set_int(eventHandle, _calendar_event.busy_status, CALENDAR_EVENT_BUSY_STATUS_FREE);
 126         calendar_record_set_int(eventHandle, _calendar_event.priority, CALENDAR_EVENT_PRIORITY_NORMAL);
 127         calendar_record_set_int(eventHandle, _calendar_event.sensitivity, CALENDAR_SENSITIVITY_PUBLIC);
 128         calendar_record_set_int(eventHandle, _calendar_event.calendar_book_id, INVALID_RECORD_ID);
 129
 130         r = __reminderList.Construct();
 131         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 132 }
 133
 134 _CalEventImpl::_CalEventImpl(const _CalEventImpl& rhs)
 135         : __originalEventId(rhs.__originalEventId)
 136         , __isInstance(rhs.__isInstance)
 137         , __reminderListUpdated(false)
 138 {
 139         result r = _CalendarbookDbConnector::Connect();
 140         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 141
 142         calendar_record_h eventHandle = null;
 143         int errorCode = calendar_record_clone(rhs.__eventRecord.GetHandle(), &eventHandle);
 144         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 145
 146         __eventRecord.ResetHandle(eventHandle);
 147
 148         r = __reminderList.Construct();
 149         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 150 }
 151
 152 _CalEventImpl::~_CalEventImpl(void)
 153 {
 154         calendar_record_destroy(__eventRecord.ReleaseHandle(), true);
 155
 156         __reminderList.RemoveAll(true);
 157
 158         result r = _CalendarbookDbConnector::Disconnect();
 159         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 160 }
 161
 162 _CalEventImpl&
 163 _CalEventImpl::operator =(const _CalEventImpl& rhs)
 164 {
 165         if (this == &rhs)
 166         {
 167                 return *this;
 168         }
 169
 170         __originalEventId = rhs.__originalEventId;
 171         __isInstance = rhs.__isInstance;
 172         __reminderList.RemoveAll(true);
 173         __reminderListUpdated = false;
 174
 175         int errorCode = CALENDAR_ERROR_NONE;
 176         calendar_record_h eventHandle = null;
 177
 178         errorCode = calendar_record_clone(rhs.__eventRecord.GetHandle(), &eventHandle);
 179         SysTryReturn(NID_SCL, errorCode == CALENDAR_ERROR_NONE, *this, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 180
 181         __eventRecord.ResetHandle(eventHandle);
 182
 183         return *this;
 184 }
 185
 186 bool
 187 _CalEventImpl::IsInstance(void) const
 188 {
 189         return __isInstance;
 190 }
 191
 192 bool
 193 _CalEventImpl::IsRecurring(void) const
 194 {
 195         int recurrenceFreq = CALENDAR_RECURRENCE_NONE;
 196
 197         calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.freq, &recurrenceFreq);
 198
 199         if (recurrenceFreq == CALENDAR_RECURRENCE_NONE)
 200         {
 201                 return false;
 202         }
 203
 204         return true;
 205 }
 206
 207 RecordId
 208 _CalEventImpl::GetOriginalCalEventId(void)  const
 209 {
 210         return __originalEventId;
 211 }
 212
 213 bool
 214 _CalEventImpl::IsAllDayEvent(void)  const
 215 {
 216         calendar_time_s startCalendarTime;
 217
 218         calendar_record_get_caltime(__eventRecord.GetHandle(), _calendar_event.start_time, &startCalendarTime);
 219         if (startCalendarTime.type == CALENDAR_TIME_UTIME)
 220         {
 221                 return false;
 222         }
 223
 224         return true;
 225 }
 226
 227 void
 228 _CalEventImpl::SetAllDayEvent(bool isAllDayEvent)
 229 {
 230         if (GetCategory() == EVENT_CATEGORY_ANNIVERSARY)
 231         {
 232                 return;
 233         }
 234
 235         calendar_time_s startCalendarTime;
 236         calendar_time_s tmpStartCalendarTime;
 237         calendar_time_s endCalendarTime;
 238         calendar_time_s tmpEndCalendarTime;
 239
 240         bool isChanged = false;
 241
 242         calendar_record_get_caltime(__eventRecord.GetHandle(), _calendar_event.start_time, &startCalendarTime);
 243         calendar_record_get_caltime(__eventRecord.GetHandle(), _calendar_event.end_time, &endCalendarTime);
 244
 245         if (isAllDayEvent && startCalendarTime.type == CALENDAR_TIME_UTIME)
 246         {
 247                 tmpStartCalendarTime.type = CALENDAR_TIME_LOCALTIME;
 248                 DateTime tmpStartTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(startCalendarTime.time.utime);
 249                 tmpStartCalendarTime.time.date.year = tmpStartTime.GetYear();
 250                 tmpStartCalendarTime.time.date.month = tmpStartTime.GetMonth();
 251                 tmpStartCalendarTime.time.date.mday = tmpStartTime.GetDay();
 252
 253                 tmpEndCalendarTime.type = CALENDAR_TIME_LOCALTIME;
 254                 DateTime tmpEndTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(endCalendarTime.time.utime);
 255                 tmpEndCalendarTime.time.date.year = tmpEndTime.GetYear();
 256                 tmpEndCalendarTime.time.date.month = tmpEndTime.GetMonth();
 257                 tmpEndCalendarTime.time.date.mday = tmpEndTime.GetDay();
 258
 259                 calendar_record_set_caltime(__eventRecord.GetHandle(), _calendar_event.start_time, tmpStartCalendarTime);
 260                 calendar_record_set_caltime(__eventRecord.GetHandle(), _calendar_event.end_time, tmpEndCalendarTime);
 261
 262                 isChanged = true;
 263         }
 264         else if (!isAllDayEvent && startCalendarTime.type == CALENDAR_TIME_LOCALTIME)
 265         {
 266                 tmpStartCalendarTime.type = CALENDAR_TIME_UTIME;
 267                 DateTime tmpStartTime;
 268                 tmpStartTime.SetValue(startCalendarTime.time.date.year, startCalendarTime.time.date.month, startCalendarTime.time.date.mday);
 269                 tmpStartCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(tmpStartTime);
 270
 271                 tmpEndCalendarTime.type = CALENDAR_TIME_UTIME;
 272                 DateTime tmpEndTime;
 273                 tmpEndTime.SetValue(endCalendarTime.time.date.year, endCalendarTime.time.date.month, endCalendarTime.time.date.mday);
 274                 tmpEndCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(tmpEndTime);
 275
 276                 calendar_record_set_caltime(__eventRecord.GetHandle(), _calendar_event.start_time, tmpStartCalendarTime);
 277                 calendar_record_set_caltime(__eventRecord.GetHandle(), _calendar_event.end_time, tmpEndCalendarTime);
 278
 279                 isChanged = true;
 280         }
 281
 282         if (IsRecurring())
 283         {
 284                 int rangeType = CALENDAR_RANGE_NONE;
 285                 calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.range_type, &rangeType);
 286
 287                 if (rangeType == CALENDAR_RANGE_UNTIL)
 288                 {
 289                         calendar_time_s untilCalendarTime;
 290                         calendar_time_s tmpUntilCalendarTime;
 291
 292                         calendar_record_get_caltime(__eventRecord.GetHandle(), _calendar_event.until_time, &untilCalendarTime);
 293                         if (isAllDayEvent && untilCalendarTime.type == CALENDAR_TIME_UTIME)
 294                         {
 295                                 tmpUntilCalendarTime.type = CALENDAR_TIME_LOCALTIME;
 296                                 DateTime tmpUntilTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(untilCalendarTime.time.utime);
 297                                 tmpUntilCalendarTime.time.date.year = tmpUntilTime.GetYear();
 298                                 tmpUntilCalendarTime.time.date.month = tmpUntilTime.GetMonth();
 299                                 tmpUntilCalendarTime.time.date.mday = tmpUntilTime.GetDay();
 300
 301                                 calendar_record_set_caltime(__eventRecord.GetHandle(), _calendar_event.until_time, tmpUntilCalendarTime);
 302                         }
 303                         else if (!isAllDayEvent && untilCalendarTime.type == CALENDAR_TIME_LOCALTIME)
 304                         {
 305                                 tmpUntilCalendarTime.type = CALENDAR_TIME_UTIME;
 306                                 DateTime tmpUntilTime;
 307                                 tmpUntilTime.SetValue(untilCalendarTime.time.date.year, untilCalendarTime.time.date.month, untilCalendarTime.time.date.mday);
 308                                 tmpUntilCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(tmpUntilTime);
 309
 310                                 calendar_record_set_caltime(__eventRecord.GetHandle(), _calendar_event.until_time, tmpUntilCalendarTime);
 311                         }
 312                 }
 313
 314                 if (isChanged)
 315                 {
 316                         if (__pRecurrence == null)
 317                         {
 318                                 __pRecurrence.reset(ConvertEventHandleToRecurrenceN(__eventRecord.GetHandle()));
 319                         }
 320
 321                         std::unique_ptr<char[]> pExDates(_StringConverter::CopyToCharArrayN(ConvertRecurrenceToRRuleExDateString(*__pRecurrence.get(), isAllDayEvent)));
 322                         int errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.exdate, pExDates.get());
 323                         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 324                 }
 325         }
 326 }
 327
 328 ByteBuffer*
 329 _CalEventImpl::GetUIDN(void) const
 330 {
 331         ClearLastResult();
 332
 333         char* pStrUid = null;
 334         calendar_record_get_str_p(__eventRecord.GetHandle(), _calendar_event.uid, &pStrUid);
 335
 336         if (pStrUid == null || strlen(pStrUid) == 0)
 337         {
 338                 return null;
 339         }
 340
 341         ByteBuffer* pConvertedUidBuffer = _CalendarbookUtil::ConvertCharArrayToByteBufferN(pStrUid);
 342         SysTryReturn(NID_SCL, pConvertedUidBuffer != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 343
 344         return pConvertedUidBuffer;
 345 }
 346
 347 result
 348 _CalEventImpl::SetUID(const ByteBuffer* pUid)
 349 {
 350         int errorCode = CALENDAR_ERROR_NONE;
 351
 352         if (pUid != null)
 353         {
 354                 std::unique_ptr<char[]> pConvertedUidArray(_CalendarbookUtil::ConvertByteBufferToCharArrayN(*pUid));
 355                 SysTryReturn(NID_SCL, pConvertedUidArray != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 356
 357                 errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.uid, pConvertedUidArray.get());
 358                 SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 359         }
 360         else
 361         {
 362                 errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.uid, null);
 363                 SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 364         }
 365
 366         return E_SUCCESS;
 367 }
 368
 369 String
 370 _CalEventImpl::GetUid(void) const
 371 {
 372         char* pStrUid = null;
 373         calendar_record_get_str_p(__eventRecord.GetHandle(), _calendar_event.uid, &pStrUid);
 374
 375         return String(pStrUid);
 376 }
 377
 378 void
 379 _CalEventImpl::SetUid(const String& uid)
 380 {
 381         std::unique_ptr<char[]> pStrUid(_StringConverter::CopyToCharArrayN(uid));
 382         SysTryReturnVoidResult(NID_SCL, pStrUid != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 383
 384         int errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.uid, pStrUid.get());
 385         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 386 }
 387
 388 EventStatus
 389 _CalEventImpl::GetStatus(void) const
 390 {
 391         int srcEventStatus = CALENDAR_EVENT_STATUS_NONE;
 392
 393         EventStatus eventStatus = EVENT_STATUS_NONE;
 394
 395         calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.event_status, &srcEventStatus);
 396
 397         switch (srcEventStatus)
 398         {
 399         case CALENDAR_EVENT_STATUS_NONE:
 400                 eventStatus = EVENT_STATUS_NONE;
 401                 break;
 402         case CALENDAR_EVENT_STATUS_TENTATIVE:
 403                 eventStatus = EVENT_STATUS_TENTATIVE;
 404                 break;
 405         case CALENDAR_EVENT_STATUS_CONFIRMED:
 406                 eventStatus = EVENT_STATUS_CONFIRMED;
 407                 break;
 408         case CALENDAR_EVENT_STATUS_CANCELLED:
 409                 eventStatus = EVENT_STATUS_CANCELLED;
 410                 break;
 411         default :
 412                 SysLog(NID_SCL, "The status value is invalid.");
 413                 return EVENT_STATUS_NONE;
 414         }
 415
 416         return eventStatus;
 417 }
 418
 419 void
 420 _CalEventImpl::SetStatus(EventStatus status)
 421 {
 422         calendar_record_set_int(__eventRecord.GetHandle(), _calendar_event.event_status, _CalendarbookUtil::ConvertEventStatusToCSEventStatus(status));
 423 }
 424
 425 BusyStatus
 426 _CalEventImpl::GetBusyStatus(void) const
 427 {
 428         int srcEventBusyStatus = CALENDAR_EVENT_BUSY_STATUS_FREE;
 429
 430         BusyStatus busyStatus = BUSY_STATUS_FREE;
 431
 432         calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.busy_status, &srcEventBusyStatus);
 433
 434         switch (srcEventBusyStatus)
 435         {
 436         case CALENDAR_EVENT_BUSY_STATUS_FREE:
 437                 busyStatus = BUSY_STATUS_FREE;
 438                 break;
 439         case CALENDAR_EVENT_BUSY_STATUS_BUSY:
 440                 busyStatus = BUSY_STATUS_BUSY;
 441                 break;
 442         case CALENDAR_EVENT_BUSY_STATUS_UNAVAILABLE:
 443                 busyStatus = BUSY_STATUS_UNAVAILABLE;
 444                 break;
 445         case CALENDAR_EVENT_BUSY_STATUS_TENTATIVE:
 446                 busyStatus = BUSY_STATUS_TENTATIVE;
 447                 break;
 448         default :
 449                 SysLog(NID_SCL, "The busy status value is invalid.");
 450                 busyStatus = BUSY_STATUS_FREE;
 451                 break;
 452         }
 453
 454         return busyStatus;
 455 }
 456
 457 void
 458 _CalEventImpl::SetBusyStatus(BusyStatus busyStatus)
 459 {
 460         calendar_record_set_int(__eventRecord.GetHandle(), _calendar_event.busy_status, _CalendarbookUtil::ConvertBusyStatusToCSEventBusyStatus(busyStatus));
 461 }
 462
 463 EventPriority
 464 _CalEventImpl::GetPriority(void) const
 465 {
 466         int srcPriority = CALENDAR_EVENT_PRIORITY_LOW;
 467
 468         EventPriority priority = EVENT_PRIORITY_NORMAL;
 469
 470         calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.priority, &srcPriority);
 471
 472         switch (srcPriority)
 473         {
 474         case CALENDAR_EVENT_PRIORITY_LOW:
 475                 priority = EVENT_PRIORITY_LOW;
 476                 break;
 477         case CALENDAR_EVENT_PRIORITY_NONE:
 478                 // fall through
 479         case CALENDAR_EVENT_PRIORITY_NORMAL:
 480                 priority = EVENT_PRIORITY_NORMAL;
 481                 break;
 482         case CALENDAR_EVENT_PRIORITY_HIGH:
 483                 priority = EVENT_PRIORITY_HIGH;
 484                 break;
 485         default :
 486                 SysLog(NID_SCL, "The priority value is invalid.");
 487                 priority = EVENT_PRIORITY_NORMAL;
 488         }
 489
 490         return priority;
 491 }
 492
 493 void
 494 _CalEventImpl::SetPriority(EventPriority priority)
 495 {
 496         calendar_record_set_int(__eventRecord.GetHandle(), _calendar_event.priority, _CalendarbookUtil::ConvertEventPriorityToCSEventPriority(priority));
 497 }
 498
 499 result
 500 _CalEventImpl::AddAttendee(const Attendee& attendee)
 501 {
 502         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0)
 503         {
 504                 SysTryReturnResult(NID_SCL, !attendee.GetEmail().IsEmpty(), E_OBJ_ALREADY_EXIST
 505                                         , "The attendee's email string is empty.");
 506         }
 507         else
 508         {
 509                 SysTryReturnResult(NID_SCL, !attendee.GetEmail().IsEmpty(), E_INVALID_ARG
 510                                         , "The attendee's email string is empty.");
 511         }
 512
 513         std::unique_ptr<char[]> pConvertedEmail(_StringConverter::CopyToCharArrayN(attendee.GetEmail()));
 514         SysTryReturnResult(NID_SCL, pConvertedEmail != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 515
 516         SysTryReturnResult(NID_SCL, GetAttendeeIndex(pConvertedEmail.get()) == _INVALID_ATTENDEE_INDEX, E_OBJ_ALREADY_EXIST
 517                                 , "The specified attendee already exists as this email is already registered.");
 518
 519         std::unique_ptr<char[]> pConvertedName(_StringConverter::CopyToCharArrayN(attendee.GetName()));
 520         SysTryReturnResult(NID_SCL, pConvertedName != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 521
 522         std::unique_ptr<char[]> pConvertedPhoneNumber(_StringConverter::CopyToCharArrayN(attendee.GetPhoneNumber()));
 523         SysTryReturnResult(NID_SCL, pConvertedPhoneNumber != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 524
 525         calendar_attendee_status_e convertedStatus = CALENDAR_ATTENDEE_STATUS_TENTATIVE;
 526         switch (attendee.GetStatus())
 527         {
 528         case ATTENDEE_STATUS_NONE:
 529                 convertedStatus = CALENDAR_ATTENDEE_STATUS_COMPLETED;
 530                 break;
 531         case ATTENDEE_STATUS_NOT_RESPONDED:
 532                 convertedStatus = CALENDAR_ATTENDEE_STATUS_PENDING;
 533                 break;
 534         case ATTENDEE_STATUS_ACCEPTED:
 535                 convertedStatus = CALENDAR_ATTENDEE_STATUS_ACCEPTED;
 536                 break;
 537         case ATTENDEE_STATUS_DECLINED:
 538                 convertedStatus = CALENDAR_ATTENDEE_STATUS_DECLINED;
 539                 break;
 540         case ATTENDEE_STATUS_TENTATIVE:
 541                 convertedStatus = CALENDAR_ATTENDEE_STATUS_TENTATIVE;
 542                 break;
 543         default:
 544                 SysLog(NID_SCL, "The attendee status value is invalid. attendee status = %d", attendee.GetStatus());
 545                 convertedStatus = CALENDAR_ATTENDEE_STATUS_TENTATIVE;
 546                 break;
 547         }
 548
 549         calendar_attendee_role_e convertedRole = CALENDAR_ATTENDEE_ROLE_NON_PARTICIPANT;
 550         switch (attendee.GetRole())
 551         {
 552         case ATTENDEE_ROLE_ATTENDEE:
 553                 convertedRole = CALENDAR_ATTENDEE_ROLE_OPT_PARTICIPANT;
 554                 break;
 555         case ATTENDEE_ROLE_REQUIRED_ATTENDEE:
 556                 convertedRole = CALENDAR_ATTENDEE_ROLE_REQ_PARTICIPANT;
 557                 break;
 558         case ATTENDEE_ROLE_ORGANIZER:
 559                 convertedRole = CALENDAR_ATTENDEE_ROLE_CHAIR;
 560                 break;
 561         default:
 562                 SysLog(NID_SCL, "The attendee role value is invalid. attendee role = %d", attendee.GetRole());
 563                 convertedRole = CALENDAR_ATTENDEE_ROLE_OPT_PARTICIPANT;
 564                 break;
 565         }
 566
 567         calendar_record_h attendeeHandle = null;
 568         int errorCode = calendar_record_create(_calendar_attendee._uri, &attendeeHandle);
 569         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 570
 571         errorCode = calendar_record_set_str(attendeeHandle, _calendar_attendee.name, pConvertedName.get());
 572         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 573         errorCode = calendar_record_set_str(attendeeHandle, _calendar_attendee.email, pConvertedEmail.get());
 574         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 575         errorCode = calendar_record_set_str(attendeeHandle, _calendar_attendee.number, pConvertedPhoneNumber.get());
 576         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 577         calendar_record_set_int(attendeeHandle, _calendar_attendee.status, convertedStatus);
 578         calendar_record_set_int(attendeeHandle, _calendar_attendee.role, convertedRole);
 579         calendar_record_set_int(attendeeHandle, _calendar_attendee.person_id, attendee.GetPersonId());
 580
 581         errorCode = calendar_record_add_child_record(__eventRecord.GetHandle(), _calendar_event.calendar_attendee, attendeeHandle);
 582         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 583
 584         return E_SUCCESS;
 585 }
 586
 587 result
 588 _CalEventImpl::RemoveAttendee(const Attendee& attendee)
 589 {
 590         std::unique_ptr<char[]> pConvertedEmail(_StringConverter::CopyToCharArrayN(attendee.GetEmail()));
 591         SysTryReturnResult(NID_SCL, pConvertedEmail != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 592
 593         int index = GetAttendeeIndex(pConvertedEmail.get());
 594         SysTryReturnResult(NID_SCL, index != _INVALID_ATTENDEE_INDEX, E_OBJ_NOT_FOUND, "The specified attendee does not exist.");
 595
 596         calendar_record_h tmpAttendeeHandle = null;
 597         calendar_record_get_child_record_at_p(__eventRecord.GetHandle(), _calendar_event.calendar_attendee, index, &tmpAttendeeHandle);
 598         calendar_record_remove_child_record(__eventRecord.GetHandle(), _calendar_event.calendar_attendee, tmpAttendeeHandle);
 599
 600         return E_SUCCESS;
 601 }
 602
 603 IList*
 604 _CalEventImpl::GetAllAttendeesN(void) const
 605 {
 606         ClearLastResult();
 607
 608         std::unique_ptr<ArrayList, AllElementsDeleter> pList(new (std::nothrow) ArrayList());
 609         SysTryReturn(NID_SCL, pList != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 610         result r = pList->Construct();
 611         SysTryReturn(NID_SCL, !IsFailed(r), null, r, "[%s] Propagating.", GetErrorMessage(r));
 612
 613         unsigned int attendeeCount = 0;
 614         calendar_record_get_child_record_count(__eventRecord.GetHandle(), _calendar_event.calendar_attendee, &attendeeCount);
 615
 616         for (unsigned int i = 0; i < attendeeCount; i++)
 617         {
 618                 calendar_record_h tmpAttendeeHandle = null;
 619                 char* pTmpEmail = null;
 620                 char* pTmpName = null;
 621                 char* pTmpPhoneNumber = null;
 622                 int tmpStatus = 0;
 623                 int tmpRole = 0;
 624                 int tmpPersonId = -1;
 625                 AttendeeStatus attendeeStatus = ATTENDEE_STATUS_NONE;
 626                 AttendeeRole attendeeRole = ATTENDEE_ROLE_ATTENDEE;
 627
 628                 calendar_record_get_child_record_at_p(__eventRecord.GetHandle(), _calendar_event.calendar_attendee, i, &tmpAttendeeHandle);
 629                 calendar_record_get_str_p(tmpAttendeeHandle, _calendar_attendee.email, &pTmpEmail);
 630                 calendar_record_get_str_p(tmpAttendeeHandle, _calendar_attendee.name, &pTmpName);
 631                 calendar_record_get_str_p(tmpAttendeeHandle, _calendar_attendee.number, &pTmpPhoneNumber);
 632                 calendar_record_get_int(tmpAttendeeHandle, _calendar_attendee.status, &tmpStatus);
 633                 calendar_record_get_int(tmpAttendeeHandle, _calendar_attendee.role, &tmpRole);
 634                 calendar_record_get_int(tmpAttendeeHandle, _calendar_attendee.person_id, &tmpPersonId);
 635
 636                 switch (tmpStatus)
 637                 {
 638                 case CALENDAR_ATTENDEE_STATUS_PENDING:
 639                         attendeeStatus = ATTENDEE_STATUS_NOT_RESPONDED;
 640                         break;
 641                 case CALENDAR_ATTENDEE_STATUS_ACCEPTED:
 642                         attendeeStatus = ATTENDEE_STATUS_ACCEPTED;
 643                         break;
 644                 case CALENDAR_ATTENDEE_STATUS_DECLINED:
 645                         attendeeStatus = ATTENDEE_STATUS_DECLINED;
 646                         break;
 647                 case CALENDAR_ATTENDEE_STATUS_TENTATIVE:
 648                         attendeeStatus = ATTENDEE_STATUS_TENTATIVE;
 649                         break;
 650                 case CALENDAR_ATTENDEE_STATUS_DELEGATED:
 651                         attendeeStatus = ATTENDEE_STATUS_NONE;
 652                         break;
 653                 case CALENDAR_ATTENDEE_STATUS_COMPLETED:
 654                         attendeeStatus = ATTENDEE_STATUS_NONE;
 655                         break;
 656                 case CALENDAR_ATTENDEE_STATUS_IN_PROCESS:
 657                         attendeeStatus = ATTENDEE_STATUS_NOT_RESPONDED;
 658                         break;
 659                 default:
 660                         SysLog(NID_SCL, "The attendee status value is invalid. attendee status = %d", tmpStatus);
 661                         attendeeStatus = ATTENDEE_STATUS_NONE;
 662                         break;
 663                 }
 664
 665                 switch (tmpRole)
 666                 {
 667                 case CALENDAR_ATTENDEE_ROLE_REQ_PARTICIPANT:
 668                         attendeeRole = ATTENDEE_ROLE_REQUIRED_ATTENDEE;
 669                         break;
 670                 case CALENDAR_ATTENDEE_ROLE_OPT_PARTICIPANT:
 671                         attendeeRole = ATTENDEE_ROLE_ATTENDEE;
 672                         break;
 673                 case CALENDAR_ATTENDEE_ROLE_NON_PARTICIPANT:
 674                         attendeeRole = ATTENDEE_ROLE_ATTENDEE;
 675                         break;
 676                 case CALENDAR_ATTENDEE_ROLE_CHAIR:
 677                         attendeeRole = ATTENDEE_ROLE_ORGANIZER;
 678                         break;
 679                 default:
 680                         SysLog(NID_SCL, "The attendee role value is invalid. attendee role = %d", tmpRole);
 681                         attendeeRole = ATTENDEE_ROLE_ATTENDEE;
 682                         break;
 683                 }
 684
 685                 std::unique_ptr<Attendee> pTmpAttendee(new (std::nothrow) Attendee(pTmpEmail));
 686                 SysTryReturn(NID_SCL, pTmpAttendee != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 687
 688                 if (pTmpName != null && strlen(pTmpName) > 0)
 689                 {
 690                         pTmpAttendee->SetName(pTmpName);
 691                 }
 692
 693                 if (pTmpPhoneNumber != null && strlen(pTmpPhoneNumber) > 0)
 694                 {
 695                         pTmpAttendee->SetPhoneNumber(pTmpPhoneNumber);
 696                 }
 697
 698                 pTmpAttendee->SetStatus(attendeeStatus);
 699                 pTmpAttendee->SetRole(attendeeRole);
 700                 pTmpAttendee->SetPersonId(tmpPersonId);
 701
 702                 r = pList->Add(pTmpAttendee.get());
 703                 SysTryReturn(NID_SCL, !IsFailed(r), null, r, "[%s] Propagating.", GetErrorMessage(r));
 704
 705                 pTmpAttendee.release();
 706         }
 707
 708         return pList.release();
 709 }
 710
 711 TimeZone
 712 _CalEventImpl::GetTimeZone(void) const
 713 {
 714         char* pTimeZoneId = null;
 715         TimeZone timeZone;
 716
 717         calendar_record_get_str_p(__eventRecord.GetHandle(), _calendar_event.start_tzid, &pTimeZoneId);
 718         if (pTimeZoneId != null && strlen(pTimeZoneId) > 0)
 719         {
 720                 DateTime startTime = GetStartTime();
 721
 722                 TimeZone::GetTimeZone(pTimeZoneId, startTime, timeZone);
 723         }
 724
 725         return timeZone;
 726 }
 727
 728 result
 729 _CalEventImpl::SetTimeZone(const TimeZone& timeZone)
 730 {
 731         std::unique_ptr<char[]> pConvertedTimeZoneId(_StringConverter::CopyToCharArrayN(timeZone.GetId()));
 732         SysTryReturnResult(NID_SCL, pConvertedTimeZoneId != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 733
 734         int errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.start_tzid, pConvertedTimeZoneId.get());
 735         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 736         errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.end_tzid, pConvertedTimeZoneId.get());
 737         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 738
 739         return E_SUCCESS;
 740 }
 741
 742 RecurrenceId
 743 _CalEventImpl::GetRecurrenceId(void) const
 744 {
 745         ClearLastResult();
 746         SysTryReturn(NID_SCL, __isInstance, DateTime(), E_INVALID_STATE,
 747                                 "[%s] The instance does not have a recurrence or is not a CalEvent instance which doesn't have a RecurrenceId.", GetErrorMessage(E_INVALID_STATE));
 748
 749         return GetStartTime();
 750 }
 751
 752 String
 753 _CalEventImpl::GetSubject(void) const
 754 {
 755         char* pSubject = null;
 756
 757         calendar_record_get_str_p(__eventRecord.GetHandle(), _calendar_event.summary, &pSubject);
 758
 759         return String(pSubject);
 760 }
 761
 762 String
 763 _CalEventImpl::GetDescription(void) const
 764 {
 765         char* pDescription = null;
 766
 767         calendar_record_get_str_p(__eventRecord.GetHandle(), _calendar_event.description, &pDescription);
 768
 769         return String(pDescription);
 770 }
 771 DateTime
 772 _CalEventImpl::GetStartTime(void) const
 773 {
 774         calendar_time_s startCalendarTime;
 775         DateTime tmpStartTime;
 776
 777         calendar_record_get_caltime(__eventRecord.GetHandle(), _calendar_event.start_time, &startCalendarTime);
 778
 779         if (startCalendarTime.type == CALENDAR_TIME_UTIME)
 780         {
 781                 tmpStartTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(startCalendarTime.time.utime);
 782         }
 783         else
 784         {
 785                 tmpStartTime.SetValue(startCalendarTime.time.date.year, startCalendarTime.time.date.month, startCalendarTime.time.date.mday);
 786         }
 787
 788         return tmpStartTime;
 789 }
 790
 791 DateTime
 792 _CalEventImpl::GetEndTime(void) const
 793 {
 794         calendar_time_s endCalendarTime;
 795         DateTime tmpEndTime;
 796
 797         calendar_record_get_caltime(__eventRecord.GetHandle(), _calendar_event.end_time, &endCalendarTime);
 798
 799         if (endCalendarTime.type == CALENDAR_TIME_UTIME)
 800         {
 801                 tmpEndTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(endCalendarTime.time.utime);
 802         }
 803         else if (endCalendarTime.type == CALENDAR_TIME_LOCALTIME)
 804         {
 805                 tmpEndTime.SetValue(endCalendarTime.time.date.year, endCalendarTime.time.date.month, endCalendarTime.time.date.mday);
 806         }
 807
 808         return tmpEndTime;
 809 }
 810
 811 String
 812 _CalEventImpl::GetLocation(void) const
 813 {
 814         char* pLocation = null;
 815
 816         calendar_record_get_str_p(__eventRecord.GetHandle(), _calendar_event.location, &pLocation);
 817
 818         return String(pLocation);
 819 }
 820
 821 EventCategory
 822 _CalEventImpl::GetCategory(void) const
 823 {
 824         char* pCategories = null;
 825
 826         calendar_record_get_str_p(__eventRecord.GetHandle(), _calendar_event.categories, &pCategories);
 827
 828         return _CalendarbookUtil::ConvertCSCategoriesToEventCategory(pCategories);
 829 }
 830
 831 RecordSensitivity
 832 _CalEventImpl::GetSensitivity(void) const
 833 {
 834         int srcSensitivity = CALENDAR_SENSITIVITY_PUBLIC;
 835         RecordSensitivity sensitivity = SENSITIVITY_PUBLIC;
 836
 837         calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.sensitivity, &srcSensitivity);
 838
 839         switch (srcSensitivity)
 840         {
 841         case CALENDAR_SENSITIVITY_PUBLIC:
 842                 sensitivity = SENSITIVITY_PUBLIC;
 843                 break;
 844         case CALENDAR_SENSITIVITY_PRIVATE:
 845                 sensitivity = SENSITIVITY_PRIVATE;
 846                 break;
 847         case CALENDAR_SENSITIVITY_CONFIDENTIAL:
 848                 sensitivity = SENSITIVITY_CONFIDENTIAL;
 849                 break;
 850         default :
 851                 SysLogException(NID_SCL, E_INVALID_ARG, "[%s] Invalid argument is used. sensitivity = %d", GetErrorMessage(E_INVALID_ARG), srcSensitivity);
 852                 sensitivity = SENSITIVITY_PUBLIC;
 853         }
 854
 855         return sensitivity;
 856 }
 857
 858 const Reminder*
 859 _CalEventImpl::GetReminder(void) const
 860 {
 861         if (__reminderListUpdated == false)
 862         {
 863                 result r = _CalendarbookUtil::ConvertEventAlarmsToReminderList(__eventRecord.GetHandle(), __reminderList);
 864                 SysTryReturn(NID_SCL, r == E_SUCCESS, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 865
 866                 __reminderListUpdated = true;
 867         }
 868
 869         if (__reminderList.GetCount() > 0)
 870         {
 871                 return static_cast<const Reminder*>(__reminderList.GetAt(0));
 872         }
 873
 874         return null;
 875 }
 876
 877 const Recurrence*
 878 _CalEventImpl::GetRecurrence(void) const
 879 {
 880         if (__pRecurrence == null)
 881         {
 882                 __pRecurrence.reset(ConvertEventHandleToRecurrenceN(__eventRecord.GetHandle()));
 883         }
 884
 885         return __pRecurrence.get();
 886 }
 887
 888 Recurrence*
 889 _CalEventImpl::ConvertEventHandleToRecurrenceN(calendar_record_h eventHandle) const
 890 {
 891         int srcFrequency = CALENDAR_RECURRENCE_NONE;
 892         calendar_time_s untilCalendarTime;
 893         int rangeType = CALENDAR_RANGE_NONE;
 894         int count = 0;
 895         int interval = 0;
 896         char* pByDay = null;
 897         char* pByMonthDay = null;
 898         char* pByMonth = null;
 899         int weekStart = 0;
 900         char* pExDates = null;
 901
 902         result r = E_SUCCESS;
 903         int dayOfWeek = 0;
 904         int monthOfYear = 0;
 905         int dayOfMonth = 0;
 906         int weekOfMonth = 0;
 907         CalDayOfWeek convertedWeekStart = CAL_SUNDAY;
 908
 909         std::unique_ptr<Recurrence> pRecurrence(new (std::nothrow) Recurrence());
 910
 911         calendar_record_get_int(eventHandle, _calendar_event.freq, &srcFrequency);
 912
 913         if (srcFrequency == CALENDAR_RECURRENCE_NONE)
 914         {
 915                 return null;
 916         }
 917
 918         calendar_record_get_int(eventHandle, _calendar_event.range_type, &rangeType);
 919         calendar_record_get_int(eventHandle, _calendar_event.count, &count);
 920         calendar_record_get_int(eventHandle, _calendar_event.interval, &interval);
 921         calendar_record_get_caltime(eventHandle, _calendar_event.until_time, &untilCalendarTime);
 922         calendar_record_get_int(eventHandle, _calendar_event.wkst, &weekStart);
 923
 924         calendar_record_get_str_p(eventHandle, _calendar_event.byday, &pByDay);
 925         calendar_record_get_str_p(eventHandle, _calendar_event.bymonthday, &pByMonthDay);
 926         if (pByMonthDay != null)
 927         {
 928                 r = Integer::Parse(pByMonthDay, dayOfMonth);
 929                 SysTryReturn(NID_SCL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 930         }
 931         calendar_record_get_str_p(eventHandle, _calendar_event.bymonth, &pByMonth);
 932         if (pByMonth != null)
 933         {
 934                 r = Integer::Parse(pByMonth, monthOfYear);
 935                 SysTryReturn(NID_SCL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 936         }
 937
 938         switch (srcFrequency)
 939         {
 940         case CALENDAR_RECURRENCE_DAILY:
 941                 pRecurrence->SetFrequency(FREQ_DAILY);
 942                 break;
 943
 944         case CALENDAR_RECURRENCE_WEEKLY:
 945                 pRecurrence->SetFrequency(FREQ_WEEKLY);
 946
 947                 dayOfWeek = ConvertRRuleByDayStringToDayOfWeek(pByDay);
 948                 SysTryReturn(NID_SCL, GetLastResult() == E_SUCCESS, null, E_INVALID_ARG, "[%s] Invalid argument is used. byday = %s", GetErrorMessage(E_INVALID_ARG), pByDay);
 949
 950                 pRecurrence->SetDayOfWeek(dayOfWeek);
 951                 break;
 952
 953         case CALENDAR_RECURRENCE_MONTHLY:
 954                 pRecurrence->SetFrequency(FREQ_MONTHLY);
 955
 956                 if (dayOfMonth != 0)
 957                 {
 958                         if (dayOfMonth < 0)
 959                         {
 960                                 int maxDaysOfMonth = _CalendarbookUtil::GetMaxDaysOfMonth(untilCalendarTime.time.date.year, monthOfYear);
 961                                 pRecurrence->SetDayOfMonth(maxDaysOfMonth + dayOfMonth);
 962                         }
 963                         else
 964                         {
 965                                 pRecurrence->SetDayOfMonth(dayOfMonth);
 966                         }
 967                 }
 968                 else
 969                 {
 970                         if(pByDay != null)
 971                         {
 972                                 r = ConvertRRuleByDayStringToDayOfWeekAndWeekOfMonth(pByDay, weekOfMonth, dayOfWeek);
 973                                 SysTryReturn(NID_SCL, r == E_SUCCESS, null, E_INVALID_ARG, "[%s] Invalid argument is used. byday = %s", GetErrorMessage(E_INVALID_ARG), pByDay);
 974
 975                                 pRecurrence->SetWeekOfMonth(weekOfMonth);
 976                                 pRecurrence->SetDayOfWeek(dayOfWeek);
 977                         }
 978                         else
 979                         {
 980                                 DateTime startTime = GetStartTime();
 981
 982                                 dayOfMonth = startTime.GetDay();
 983                                 pRecurrence->SetDayOfMonth(dayOfMonth);
 984                         }
 985                 }
 986
 987                 break;
 988
 989         case CALENDAR_RECURRENCE_YEARLY:
 990                 pRecurrence->SetFrequency(FREQ_YEARLY);
 991
 992                 if (dayOfMonth != 0)
 993                 {
 994                         if (dayOfMonth < 0)
 995                         {
 996                                 int maxDaysOfMonth = _CalendarbookUtil::GetMaxDaysOfMonth(untilCalendarTime.time.date.year, monthOfYear);
 997                                 pRecurrence->SetDayOfMonth(maxDaysOfMonth + dayOfMonth);
 998                         }
 999                         else
1000                         {
1001                                 pRecurrence->SetDayOfMonth(dayOfMonth);
1002                         }
1003                 }
1004                 else
1005                 {
1006                         if(pByDay != null)
1007                         {
1008                                 r = ConvertRRuleByDayStringToDayOfWeekAndWeekOfMonth(pByDay, weekOfMonth, dayOfWeek);
1009                                 SysTryReturn(NID_SCL, r == E_SUCCESS, null, E_INVALID_ARG, "[%s] Invalid argument is used. byday = %s", GetErrorMessage(E_INVALID_ARG), pByDay);
1010
1011                                 pRecurrence->SetWeekOfMonth(weekOfMonth);
1012                                 pRecurrence->SetDayOfWeek(dayOfWeek);
1013                         }
1014                         else
1015                         {
1016                                 DateTime startTime = GetStartTime();
1017
1018                                 dayOfMonth = startTime.GetDay();
1019                                 monthOfYear = startTime.GetMonth();
1020
1021                                 pRecurrence->SetDayOfMonth(dayOfMonth);
1022                         }
1023                 }
1024                 pRecurrence->SetMonthOfYear(monthOfYear);
1025
1026                 break;
1027
1028         default :
1029                 SysLogException(NID_SCL, E_INVALID_ARG, "Invalid argument is passed. frequency = %d", srcFrequency);
1030                 return null;
1031         }
1032
1033         if (rangeType == CALENDAR_RANGE_NONE)
1034         {
1035                 pRecurrence->SetUntil(&DateTime::GetMaxValue());
1036         }
1037         else if (rangeType == CALENDAR_RANGE_UNTIL)
1038         {
1039                 DateTime until;
1040
1041                 if (untilCalendarTime.type == CALENDAR_TIME_LOCALTIME)
1042                 {
1043                         until.SetValue(untilCalendarTime.time.date.year, untilCalendarTime.time.date.month, untilCalendarTime.time.date.mday);
1044                 }
1045                 else
1046                 {
1047                         until = _CalendarbookUtil::ConvertEpochTimeToDateTime(untilCalendarTime.time.utime);
1048                 }
1049
1050                 pRecurrence->SetUntil(&until);
1051         }
1052         else
1053         {
1054                 pRecurrence->SetCounts(count);
1055         }
1056         pRecurrence->SetInterval(interval);
1057
1058         switch (weekStart)
1059         {
1060         case CALENDAR_SUNDAY:
1061                 convertedWeekStart = CAL_SUNDAY;
1062                 break;
1063
1064         case CALENDAR_MONDAY:
1065                 convertedWeekStart = CAL_MONDAY;
1066                 break;
1067
1068         default:
1069                 SysLogException(NID_SCL, E_INVALID_ARG, "Invalid argument is passed. week start = %d", weekStart);
1070                 return null;
1071         }
1072         pRecurrence->SetWeekStart(convertedWeekStart);
1073
1074         calendar_record_get_str_p(eventHandle, _calendar_event.exdate, &pExDates);
1075         if (pExDates != null && strlen(pExDates) != 0)
1076         {
1077                 r = ConvertRRuleExDateStringToRecurrence(pExDates, *pRecurrence.get());
1078                 SysTryReturn(NID_SCL, r == E_SUCCESS, null, E_INVALID_ARG, "[%s] Invalid argument is used. exdate = %s", GetErrorMessage(E_INVALID_ARG), pExDates);
1079         }
1080
1081         return pRecurrence.release();
1082 }
1083
1084 DateTime
1085 _CalEventImpl::GetLastRevisedTime(void) const
1086 {
1087         long long lastModifiedTime = 0;
1088         DateTime tmpLastRevisedTime;
1089
1090         calendar_record_get_lli(__eventRecord.GetHandle(), _calendar_event.last_modified_time, &lastModifiedTime);
1091
1092         tmpLastRevisedTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(lastModifiedTime);
1093
1094         return tmpLastRevisedTime;
1095 }
1096
1097 result
1098 _CalEventImpl::SetSubject(const String& subject)
1099 {
1100         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
1101         {
1102                 SysTryReturnResult(NID_SCL, subject.GetLength() <= MAX_EVENT_SUBJECT_LENGTH, E_INVALID_ARG
1103                                 , "The length of the value exceeds MAX_EVENT_SUBJECT_LENGTH.");
1104         }
1105
1106         std::unique_ptr<char[]> pConvertedSubject(_StringConverter::CopyToCharArrayN(subject));
1107         SysTryReturnResult(NID_SCL, pConvertedSubject != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
1108
1109         int errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.summary, pConvertedSubject.get());
1110         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1111
1112         return E_SUCCESS;
1113 }
1114
1115 result
1116 _CalEventImpl::SetDescription(const String& description)
1117 {
1118         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
1119         {
1120                 SysTryReturnResult(NID_SCL, description.GetLength() <= MAX_EVENT_DESCRIPTION_LENGTH, E_INVALID_ARG
1121                                 , "The length of the value exceeds MAX_EVENT_DESCRIPTION_LENGTH.");
1122         }
1123
1124         std::unique_ptr<char[]> pConvertedDescription(_StringConverter::CopyToCharArrayN(description));
1125         SysTryReturnResult(NID_SCL, pConvertedDescription != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
1126
1127         int errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.description, pConvertedDescription.get());
1128         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1129
1130         return E_SUCCESS;
1131 }
1132
1133 result
1134 _CalEventImpl::SetLocation(const String& location)
1135 {
1136         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
1137         {
1138                 SysTryReturnResult(NID_SCL, location.GetLength() <= MAX_EVENT_LOCATION_LENGTH, E_INVALID_ARG
1139                                 , "The length of the value exceeds MAX_EVENT_LOCATION_LENGTH.");
1140         }
1141
1142         std::unique_ptr<char[]> pConvertedLocation(_StringConverter::CopyToCharArrayN(location));
1143         SysTryReturnResult(NID_SCL, pConvertedLocation != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
1144
1145         int errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.location, pConvertedLocation.get());
1146         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1147
1148         return E_SUCCESS;
1149 }
1150
1151 result
1152 _CalEventImpl::SetStartAndEndTime(const DateTime& start, const DateTime& end)
1153 {
1154         int recurrenceFrequency = 0;
1155
1156         calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.freq, &recurrenceFrequency);
1157
1158         SysTryReturnResult(NID_SCL, recurrenceFrequency == CALENDAR_RECURRENCE_NONE, E_INVALID_CONDITION
1159                         , "The recurrence date is already set. Cannot modify the start and end date/time.");
1160         SysTryReturnResult(NID_SCL, _CalendarbookUtil::CheckValidDateTime(start), E_INVALID_ARG, "Invalid argument is used. start = %S", start.ToString().GetPointer());
1161         SysTryReturnResult(NID_SCL, _CalendarbookUtil::CheckValidDateTime(end), E_INVALID_ARG, "Invalid argument is used. end = %S", end.ToString().GetPointer());
1162         SysTryReturnResult(NID_SCL, start <= end, E_INVALID_ARG, "Invalid argument is used. The end date is earlier than the start date.");
1163
1164         return SetStartAndEndTimeCommon(start, end);
1165 }
1166
1167 result
1168 _CalEventImpl::SetStartAndEndTimeCommon(const DateTime& start, const DateTime& end)
1169 {
1170         calendar_time_s startCalendarTime;
1171         calendar_time_s endCalendarTime;
1172
1173         calendar_record_get_caltime(__eventRecord.GetHandle(), _calendar_event.start_time, &startCalendarTime);
1174
1175         if (startCalendarTime.type == CALENDAR_TIME_LOCALTIME)
1176         {
1177                 startCalendarTime.time.date.year = start.GetYear();
1178                 startCalendarTime.time.date.month = start.GetMonth();
1179                 startCalendarTime.time.date.mday = start.GetDay();
1180
1181                 endCalendarTime.type = CALENDAR_TIME_LOCALTIME;
1182                 endCalendarTime.time.date.year = end.GetYear();
1183                 endCalendarTime.time.date.month = end.GetMonth();
1184                 endCalendarTime.time.date.mday = end.GetDay();
1185         }
1186         else
1187         {
1188                 startCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(start);
1189
1190                 endCalendarTime.type = CALENDAR_TIME_UTIME;
1191                 endCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(end);
1192         }
1193
1194         calendar_record_set_caltime(__eventRecord.GetHandle(), _calendar_event.start_time, startCalendarTime);
1195         calendar_record_set_caltime(__eventRecord.GetHandle(), _calendar_event.end_time, endCalendarTime);
1196
1197         return E_SUCCESS;
1198 }
1199
1200 void
1201 _CalEventImpl::SetCategory(EventCategory category)
1202 {
1203         std::unique_ptr<char[]> pConvertedCategory;
1204
1205         if (category == EVENT_CATEGORY_ANNIVERSARY)
1206         {
1207                 SetAllDayEvent(true);
1208
1209                 pConvertedCategory.reset(_StringConverter::CopyToCharArrayN(_EVENT_CATEGORY_ANNIVERSARY_STRING));
1210                 SysTryReturnVoidResult(NID_SCL, pConvertedCategory != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1211         }
1212         else
1213         {
1214                 pConvertedCategory.reset(_StringConverter::CopyToCharArrayN(_EVENT_CATEGORY_APPOINTMENT_STRING));
1215                 SysTryReturnVoidResult(NID_SCL, pConvertedCategory != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1216         }
1217
1218         int errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.categories, pConvertedCategory.get());
1219         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1220 }
1221
1222 void
1223 _CalEventImpl::SetSensitivity(RecordSensitivity sensitivity)
1224 {
1225         calendar_record_set_int(__eventRecord.GetHandle(), _calendar_event.sensitivity, _CalendarbookUtil::ConvertSensitivityToCSSensitivity(sensitivity));
1226 }
1227
1228 result
1229 _CalEventImpl::SetCoordinates(double latitude, double longitude)
1230 {
1231         SysTryReturnResult(NID_SCL, latitude >= _MIN_LATITUDE && latitude <= _MAX_LATITUDE, E_INVALID_ARG, "Invalid argument is used. The latitude is out of range.");
1232         SysTryReturnResult(NID_SCL, longitude >= _MIN_LONGITUDE && longitude <= _MAX_LONGITUDE, E_INVALID_ARG, "Invalid argument is used. The longitude is out of range.");
1233
1234         calendar_record_set_double(__eventRecord.GetHandle(), _calendar_event.latitude, latitude);
1235         calendar_record_set_double(__eventRecord.GetHandle(), _calendar_event.longitude, longitude);
1236
1237         return E_SUCCESS;
1238 }
1239
1240 void
1241 _CalEventImpl::GetCoordinates(double& latitude, double& longitude) const
1242 {
1243         calendar_record_get_double(__eventRecord.GetHandle(), _calendar_event.latitude, &latitude);
1244         calendar_record_get_double(__eventRecord.GetHandle(), _calendar_event.longitude, &longitude);
1245 }
1246
1247 result
1248 _CalEventImpl::SetReminder(const Reminder* pReminder)
1249 {
1250         unsigned int reminderCount = 0;
1251         calendar_record_h tmpAlarmHandle = null;
1252
1253         calendar_record_get_child_record_count(__eventRecord.GetHandle(), _calendar_event.calendar_alarm, &reminderCount);
1254
1255         if (pReminder != null)
1256         {
1257                 int convertedTimeUnit = 0;
1258                 switch (pReminder->GetTimeUnit())
1259                 {
1260                 case REMINDER_TIME_UNIT_MINUTE:
1261                         convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_MINUTE;
1262                         break;
1263                 case REMINDER_TIME_UNIT_HOUR:
1264                         convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_HOUR;
1265                         break;
1266                 case REMINDER_TIME_UNIT_DAY:
1267                         convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_DAY;
1268                         break;
1269                 case REMINDER_TIME_UNIT_WEEK:
1270                         convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_WEEK;
1271                         break;
1272                 default:
1273                         break;
1274                 }
1275
1276                 calendar_record_h tmpAlarmHandle = null;
1277                 int errorCode = CALENDAR_ERROR_NONE;
1278
1279                 if (reminderCount > 0)
1280                 {
1281                         calendar_record_get_child_record_at_p(__eventRecord.GetHandle(), _calendar_event.calendar_alarm, 0, &tmpAlarmHandle);
1282                         calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick_unit, convertedTimeUnit);
1283                         calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick, pReminder->GetTimeOffset());
1284
1285                         std::unique_ptr<char[]> pTmpAlarmTone(_StringConverter::CopyToCharArrayN(pReminder->GetSoundFile()));
1286                         SysTryReturnResult(NID_SCL, pTmpAlarmTone != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
1287
1288                         errorCode = calendar_record_set_str(tmpAlarmHandle, _calendar_alarm.tone, pTmpAlarmTone.get());
1289                         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1290                 }
1291                 else
1292                 {
1293                         std::unique_ptr<char[]> pTmpAlarmTone(_StringConverter::CopyToCharArrayN(pReminder->GetSoundFile()));
1294                         SysTryReturnResult(NID_SCL, pTmpAlarmTone != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
1295
1296                         errorCode = calendar_record_create(_calendar_alarm._uri, &tmpAlarmHandle);
1297                         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1298
1299                         calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick_unit, convertedTimeUnit);
1300                         calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick, pReminder->GetTimeOffset());
1301                         errorCode = calendar_record_set_str(tmpAlarmHandle, _calendar_alarm.tone, pTmpAlarmTone.get());
1302                         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1303
1304                         errorCode = calendar_record_add_child_record(__eventRecord.GetHandle(), _calendar_event.calendar_alarm, tmpAlarmHandle);
1305                         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1306                 }
1307         }
1308         else
1309         {
1310                 if (reminderCount > 0)
1311                 {
1312                         calendar_record_get_child_record_at_p(__eventRecord.GetHandle(), _calendar_event.calendar_alarm, 0, &tmpAlarmHandle);
1313                         calendar_record_remove_child_record(__eventRecord.GetHandle(), _calendar_event.calendar_alarm, tmpAlarmHandle);
1314                 }
1315         }
1316
1317         __reminderList.RemoveAll(true);
1318         __reminderListUpdated = false;
1319
1320         return E_SUCCESS;
1321 }
1322
1323 result
1324 _CalEventImpl::SetRecurrence(const Recurrence* pRecurrence)
1325 {
1326         if (pRecurrence != null)
1327         {
1328                 result r = VerifyRecurrence(*pRecurrence);
1329                 SysTryReturn(NID_SCL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1330
1331                 r = ResetStartAndEndTimeByRecurrence(*pRecurrence);
1332                 SysTryReturn(NID_SCL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1333
1334                 r = ConvertRecurrenceToEventHandle(*pRecurrence, __eventRecord.GetHandle());
1335                 SysTryReturn(NID_SCL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1336
1337                 std::unique_ptr<char[]> pExDates(_StringConverter::CopyToCharArrayN(ConvertRecurrenceToRRuleExDateString(*pRecurrence, IsAllDayEvent())));
1338                 int errorCode = calendar_record_set_str(__eventRecord.GetHandle(), _calendar_event.exdate, pExDates.get());
1339                 SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1340
1341                 __pRecurrence.reset(new (std::nothrow) Recurrence(*pRecurrence));
1342                 SysTryReturnResult(NID_SCL, __pRecurrence != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
1343         }
1344         else
1345         {
1346                 calendar_record_set_int(__eventRecord.GetHandle(), _calendar_event.freq, CALENDAR_RECURRENCE_NONE);
1347
1348                 __pRecurrence.reset(null);
1349         }
1350
1351         return E_SUCCESS;
1352 }
1353
1354 result
1355 _CalEventImpl::AddReminder(const Reminder& reminder)
1356 {
1357         calendar_record_h tmpAlarmHandle = null;
1358
1359         std::unique_ptr<char[]> pTmpAlarmTone(_StringConverter::CopyToCharArrayN(reminder.GetSoundFile()));
1360         SysTryReturnResult(NID_SCL, pTmpAlarmTone != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
1361
1362         int errorCode = calendar_record_create(_calendar_alarm._uri, &tmpAlarmHandle);
1363         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1364
1365         int convertedTimeUnit = 0;
1366
1367         ReminderTimeUnit timeUnit = reminder.GetTimeUnit();
1368         switch (timeUnit)
1369         {
1370         case REMINDER_TIME_UNIT_MINUTE:
1371                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_MINUTE;
1372                 break;
1373
1374         case REMINDER_TIME_UNIT_HOUR:
1375                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_HOUR;
1376                 break;
1377
1378         case REMINDER_TIME_UNIT_DAY:
1379                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_DAY;
1380                 break;
1381
1382         case REMINDER_TIME_UNIT_WEEK:
1383                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_WEEK;
1384                 break;
1385
1386         case REMINDER_TIME_UNIT_NONE:
1387                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_SPECIFIC;
1388                 break;
1389
1390         default:
1391                 break;
1392         }
1393
1394         calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick_unit, convertedTimeUnit);
1395         calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick, reminder.GetTimeOffset());
1396         errorCode = calendar_record_set_str(tmpAlarmHandle, _calendar_alarm.tone, pTmpAlarmTone.get());
1397         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1398
1399         if (convertedTimeUnit == CALENDAR_ALARM_TIME_UNIT_SPECIFIC)
1400         {
1401                 calendar_record_set_lli(tmpAlarmHandle, _calendar_alarm.time, _CalendarbookUtil::ConvertDateTimeToEpochTime(reminder.GetAbsoluteTime()));
1402         }
1403
1404         errorCode = calendar_record_add_child_record(__eventRecord.GetHandle(), _calendar_event.calendar_alarm, tmpAlarmHandle);
1405         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1406
1407         __reminderList.RemoveAll(true);
1408         __reminderListUpdated = false;
1409
1410         return E_SUCCESS;
1411 }
1412
1413 result
1414 _CalEventImpl::RemoveReminderAt(int index)
1415 {
1416         calendar_record_h tmpAlarmHandle = null;
1417
1418         calendar_record_get_child_record_at_p(__eventRecord.GetHandle(), _calendar_event.calendar_alarm, index, &tmpAlarmHandle);
1419         SysTryReturnResult(NID_SCL, tmpAlarmHandle != null, E_OUT_OF_RANGE, "The index is out of range. index = %d", index);
1420
1421         calendar_record_remove_child_record(__eventRecord.GetHandle(), _calendar_event.calendar_alarm, tmpAlarmHandle);
1422
1423         __reminderList.RemoveAll(true);
1424         __reminderListUpdated = false;
1425
1426         return E_SUCCESS;
1427 }
1428
1429 const IList&
1430 _CalEventImpl::GetAllReminders(void) const
1431 {
1432         ClearLastResult();
1433
1434         if (__reminderListUpdated == false)
1435         {
1436                 result r = _CalendarbookUtil::ConvertEventAlarmsToReminderList(__eventRecord.GetHandle(), __reminderList);
1437                 SysTryReturn(NID_SCL, r == E_SUCCESS, __reminderList, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1438
1439                 __reminderListUpdated = true;
1440         }
1441
1442         return __reminderList;
1443 }
1444
1445 result
1446 _CalEventImpl::ConvertRecurrenceToEventHandle(const Recurrence& recurrence, calendar_record_h eventHandle) const
1447 {
1448         result r = E_SUCCESS;
1449
1450         int weekStart = CALENDAR_SUNDAY;
1451         std::unique_ptr<char[]> pByDay;
1452         std::unique_ptr<char[]> pByMonth;
1453         std::unique_ptr<char[]> pByMonthDay;
1454
1455         int dayOfWeek = 0;
1456         String dayOfWeekString;
1457         String exDateString;
1458
1459         switch (recurrence.GetWeekStart())
1460         {
1461         case CAL_SUNDAY:
1462                 weekStart = CALENDAR_SUNDAY;
1463                 break;
1464
1465         case CAL_MONDAY:
1466                 weekStart = CALENDAR_MONDAY;
1467                 break;
1468
1469         default:
1470                 SysLogException(NID_SCL, E_INVALID_ARG, "Invalid argument is passed. week start = %d", recurrence.GetWeekStart());
1471                 return E_INVALID_ARG;
1472         }
1473
1474         int errorCode = calendar_record_set_int(eventHandle, _calendar_event.wkst, weekStart);
1475         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_INVALID_ARG, "Invalid argument is passed. week start = %d", weekStart);
1476
1477         if (recurrence.GetUntil() != null)
1478         {
1479                 if (*recurrence.GetUntil() == DateTime::GetMaxValue())
1480                 {
1481                         calendar_record_set_int(eventHandle, _calendar_event.range_type, CALENDAR_RANGE_NONE);
1482                 }
1483                 else
1484                 {
1485                         calendar_time_s startCalendarTime;
1486                         calendar_time_s untilCalendarTime;
1487
1488                         calendar_record_get_caltime(eventHandle, _calendar_event.start_time, &startCalendarTime);
1489                         if (startCalendarTime.type == CALENDAR_TIME_LOCALTIME)
1490                         {
1491                                 untilCalendarTime.type = CALENDAR_TIME_LOCALTIME;
1492                                 untilCalendarTime.time.date.year = recurrence.GetUntil()->GetYear();
1493                                 untilCalendarTime.time.date.month = recurrence.GetUntil()->GetMonth();
1494                                 untilCalendarTime.time.date.mday = recurrence.GetUntil()->GetDay();
1495                         }
1496                         else
1497                         {
1498                                 untilCalendarTime.type = CALENDAR_TIME_UTIME;
1499                                 untilCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(*recurrence.GetUntil());
1500                         }
1501
1502                         calendar_record_set_int(eventHandle, _calendar_event.range_type, CALENDAR_RANGE_UNTIL);
1503                         calendar_record_set_caltime(eventHandle, _calendar_event.until_time, untilCalendarTime);
1504                 }
1505         }
1506         else
1507         {
1508                 calendar_record_set_int(eventHandle, _calendar_event.range_type, CALENDAR_RANGE_COUNT);
1509                 calendar_record_set_int(eventHandle, _calendar_event.count, recurrence.GetCounts());
1510         }
1511
1512         calendar_record_set_int(eventHandle, _calendar_event.interval, recurrence.GetInterval());
1513
1514         switch (recurrence.GetFrequency())
1515         {
1516         case FREQ_DAILY:
1517                 calendar_record_set_int(eventHandle, _calendar_event.freq, CALENDAR_RECURRENCE_DAILY);
1518                 break;
1519
1520         case FREQ_WEEKLY:
1521                 calendar_record_set_int(eventHandle, _calendar_event.freq, CALENDAR_RECURRENCE_WEEKLY);
1522
1523                 dayOfWeek = recurrence.GetDayOfWeek();
1524                 r = ConvertDayOfWeekToRRuleByDayString(dayOfWeek, 0, dayOfWeekString);
1525                 SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_INVALID_ARG, "Invalid argument is passed. day of week = %d", dayOfWeek);
1526
1527                 pByDay.reset(_StringConverter::CopyToCharArrayN(dayOfWeekString));
1528
1529                 break;
1530
1531         case FREQ_MONTHLY:
1532                 calendar_record_set_int(eventHandle, _calendar_event.freq, CALENDAR_RECURRENCE_MONTHLY);
1533
1534                 if (recurrence.GetDayOfMonth() != 0)
1535                 {
1536                         pByMonthDay.reset(_StringConverter::CopyToCharArrayN(Integer::ToString(recurrence.GetDayOfMonth())));
1537                 }
1538                 else
1539                 {
1540                         dayOfWeek = recurrence.GetDayOfWeek();
1541                         r = ConvertDayOfWeekToRRuleByDayString(dayOfWeek, recurrence.GetWeekOfMonth(), dayOfWeekString);
1542                         SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_INVALID_ARG, "Invalid argument is passed. day of week = %d", dayOfWeek);
1543
1544                         pByDay.reset(_StringConverter::CopyToCharArrayN(dayOfWeekString));
1545                 }
1546
1547                 break;
1548
1549         case FREQ_YEARLY:
1550                 calendar_record_set_int(eventHandle, _calendar_event.freq, CALENDAR_RECURRENCE_YEARLY);
1551
1552                 pByMonth.reset(_StringConverter::CopyToCharArrayN(Integer::ToString(recurrence.GetMonthOfYear())));
1553
1554                 if (recurrence.GetDayOfMonth() != 0)
1555                 {
1556                         pByMonthDay.reset(_StringConverter::CopyToCharArrayN(Integer::ToString(recurrence.GetDayOfMonth())));
1557                 }
1558                 else
1559                 {
1560                         dayOfWeek = recurrence.GetDayOfWeek();
1561                         r = ConvertDayOfWeekToRRuleByDayString(dayOfWeek, recurrence.GetWeekOfMonth(), dayOfWeekString);
1562                         SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_INVALID_ARG, "Invalid argument is passed. day of week = %d", dayOfWeek);
1563
1564                         pByDay.reset(_StringConverter::CopyToCharArrayN(dayOfWeekString));
1565                 }
1566
1567                 break;
1568
1569         default:
1570                 SysLogException(NID_SCL, E_INVALID_ARG, "[%s] Invalid argument is used. frequency = %d", GetErrorMessage(E_INVALID_ARG), recurrence.GetFrequency());
1571                 return E_INVALID_ARG;
1572         }
1573
1574         errorCode = calendar_record_set_str(eventHandle, _calendar_event.byday, pByDay.get());
1575         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1576         errorCode = calendar_record_set_str(eventHandle, _calendar_event.bymonth, pByMonth.get());
1577         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1578         errorCode = calendar_record_set_str(eventHandle, _calendar_event.bymonthday, pByMonthDay.get());
1579         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
1580
1581         return E_SUCCESS;
1582 }
1583
1584 result
1585 _CalEventImpl::ConvertDayOfWeekToRRuleByDayString(int dayOfWeek, int weekOfMonth, String& byDayString) const
1586 {
1587         int tmpDayOfWeek = CAL_SUNDAY;
1588
1589         byDayString.Clear();
1590         for (int i = 0; i < _NUMBER_OF_DAYS_OF_WEEK; i++)
1591         {
1592                 if (dayOfWeek & tmpDayOfWeek)
1593                 {
1594                         if (weekOfMonth != 0)
1595                         {
1596                                 byDayString.Append(weekOfMonth);
1597                         }
1598
1599                         switch (tmpDayOfWeek)
1600                         {
1601                         case CAL_SUNDAY:
1602                                 byDayString.Append(_RECURRENCE_KEYWORD_SUNDAY);
1603                                 break;
1604                         case CAL_MONDAY:
1605                                 byDayString.Append(_RECURRENCE_KEYWORD_MONDAY);
1606                                 break;
1607                         case CAL_TUESDAY:
1608                                 byDayString.Append(_RECURRENCE_KEYWORD_TUESDAY);
1609                                 break;
1610                         case CAL_WEDNESDAY:
1611                                 byDayString.Append(_RECURRENCE_KEYWORD_WEDNESDAY);
1612                                 break;
1613                         case CAL_THURSDAY:
1614                                 byDayString.Append(_RECURRENCE_KEYWORD_THURSDAY);
1615                                 break;
1616                         case CAL_FRIDAY:
1617                                 byDayString.Append(_RECURRENCE_KEYWORD_FRIDAY);
1618                                 break;
1619                         case CAL_SATURDAY:
1620                                 byDayString.Append(_RECURRENCE_KEYWORD_SATURDAY);
1621                                 break;
1622                         }
1623                         byDayString.Append(_RECURRENCE_DELIMITER);
1624                 }
1625
1626                 tmpDayOfWeek <<= 1;
1627         }
1628
1629         byDayString.Remove(byDayString.GetLength() - 1, _RECURRENCE_DELIMITER_LENGTH);
1630
1631         return E_SUCCESS;
1632 }
1633
1634 RecordId
1635 _CalEventImpl::GetCalendarId(void) const
1636 {
1637         int srcCalendarbookId = 0;
1638
1639         calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.calendar_book_id, &srcCalendarbookId);
1640
1641         return srcCalendarbookId;
1642 }
1643
1644 RecordId
1645 _CalEventImpl::GetBaseEventId(void) const
1646 {
1647         int srcBaseEventId = INVALID_RECORD_ID;
1648
1649         calendar_record_get_int(__eventRecord.GetHandle(), _calendar_event.original_event_id, &srcBaseEventId);
1650
1651         return srcBaseEventId;
1652 }
1653
1654 void
1655 _CalEventImpl::SetOriginalCalEventId(RecordId originalEventId)
1656 {
1657         __originalEventId = originalEventId;
1658         __isInstance = true;
1659 }
1660
1661 int
1662 _CalEventImpl::GetAttendeeIndex(const char* pAttendeeEmail)
1663 {
1664         int index = _INVALID_ATTENDEE_INDEX;
1665         unsigned int attendeeCount = 0;
1666
1667         calendar_record_get_child_record_count(__eventRecord.GetHandle(), _calendar_event.calendar_attendee, &attendeeCount);
1668
1669         calendar_record_h tmpAttendeeHandle = null;
1670         char* pTmpAttendeeEmail = null;
1671         for (unsigned int i = 0; i < attendeeCount; i++)
1672         {
1673                 calendar_record_get_child_record_at_p(__eventRecord.GetHandle(), _calendar_event.calendar_attendee, i, &tmpAttendeeHandle);
1674                 calendar_record_get_str_p(tmpAttendeeHandle, _calendar_attendee.email, &pTmpAttendeeEmail);
1675
1676                 if (strcmp(pAttendeeEmail, pTmpAttendeeEmail) == 0)
1677                 {
1678                         index = i;
1679                         break;
1680                 }
1681         }
1682
1683         return index;
1684 }
1685
1686 result
1687 _CalEventImpl::VerifyRecurrence(const Recurrence& recurrence)
1688 {
1689         const DateTime* pUntil = recurrence.GetUntil();
1690         RecurFrequency frequency = recurrence.GetFrequency();
1691         int durationLimit = 0;
1692         int interval = recurrence.GetInterval();
1693
1694         DateTime startTime = GetStartTime();
1695         DateTime endTime = GetEndTime();
1696         EventCategory category = GetCategory();
1697
1698         if (pUntil != null)
1699         {
1700                 SysTryReturnResult(NID_SCL, startTime <= *pUntil, E_INVALID_CONDITION, "The until date of recurrence is earlier than start date.");
1701         }
1702
1703         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
1704         {
1705                 if (category == EVENT_CATEGORY_ANNIVERSARY)
1706                 {
1707                         SysTryReturnResult(NID_SCL, frequency == FREQ_YEARLY, E_TYPE_MISMATCH
1708                                         , "The recurrence pattern is not a yearly pattern in case of the event being an Anniversary.");
1709                 }
1710         }
1711
1712         if (frequency == FREQ_DAILY)
1713         {
1714                 durationLimit = _TERM_LIMIT_DAILY * interval;
1715         }
1716         else if (frequency == FREQ_WEEKLY)
1717         {
1718                 SysTryReturnResult(NID_SCL, recurrence.GetDayOfWeek() != 0, E_INVALID_ARG, "Invalid argument is used. The day of week is not set.");
1719                 durationLimit = _TERM_LIMIT_WEEKLY * interval;
1720         }
1721         else if (frequency == FREQ_MONTHLY)
1722         {
1723                 SysTryReturnResult(NID_SCL, recurrence.GetDayOfMonth() != 0 || (recurrence.GetDayOfWeek() != 0 && recurrence.GetWeekOfMonth() != 0)
1724                                 , E_INVALID_ARG, "Invalid argument is used. The day of month or day of week/week of month is not set.");
1725                 durationLimit = _TERM_LIMIT_MONTHLY * interval;
1726         }
1727         else if (frequency == FREQ_YEARLY)
1728         {
1729                 int dayOfMonth = recurrence.GetDayOfMonth();
1730                 int monthOfYear = recurrence.GetMonthOfYear();
1731                 SysTryReturnResult(NID_SCL, monthOfYear != 0, E_INVALID_ARG, "Invalid argument is used. The month of year is not set.");
1732                 SysTryReturnResult(NID_SCL, dayOfMonth != 0 || (recurrence.GetDayOfWeek() != 0 && recurrence.GetWeekOfMonth() != 0)
1733                                 , E_INVALID_ARG, "Invalid argument is used. The day of month or day of week/week of month is not set.");
1734
1735                 SysTryReturnResult(NID_SCL, monthOfYear != 2 || dayOfMonth < 30
1736                                 , E_INVALID_ARG, "Invalid argument is used. If the frequency is yearly, the max days of the February is less than 30.");
1737                 if (dayOfMonth > 30)
1738                 {
1739                         SysTryReturnResult(NID_SCL, monthOfYear != 4 && monthOfYear != 6 && monthOfYear != 9 && monthOfYear != 11
1740                                         , E_INVALID_ARG, "Invalid argument is used. If the frequency is yearly, the max days of the April, June, September and November is less than 31.");
1741                 }
1742
1743                 durationLimit = _TERM_LIMIT_YEARLY * interval;
1744         }
1745
1746         TimeSpan duration = endTime.GetTime() - startTime.GetTime();
1747         SysTryReturnResult(NID_SCL, duration.GetDays() <= durationLimit, E_INVALID_CONDITION
1748                         , "The duration of the event is greater than (interval x frequency) days. duration days = %d", duration.GetDays());
1749
1750         return E_SUCCESS;
1751 }
1752
1753 result
1754 _CalEventImpl::ResetStartAndEndTimeByRecurrence(const Recurrence& recurrence)
1755 {
1756         DateTime startTime;
1757         DateTime endTime;
1758
1759         bool isAllDay = IsAllDayEvent();
1760         Locales::TimeZone timeZone;
1761
1762         if (!isAllDay)
1763         {
1764                 timeZone = GetTimeZone();
1765                 startTime = timeZone.UtcTimeToWallTime(GetStartTime());
1766                 endTime = timeZone.UtcTimeToWallTime(GetEndTime());
1767         }
1768         else
1769         {
1770                 startTime = GetStartTime();
1771                 endTime = GetEndTime();
1772         }
1773
1774         DateTime calculatedStartTime(startTime);
1775         DateTime calculatedEndTime(endTime);
1776         RecurFrequency frequency = recurrence.GetFrequency();
1777         int interval = recurrence.GetInterval();
1778         int dayOfMonth = recurrence.GetDayOfMonth();
1779         int dayOfWeek = recurrence.GetDayOfWeek();
1780         int weekOfMonth = recurrence.GetWeekOfMonth();
1781         int monthOfYear = recurrence.GetMonthOfYear();
1782         CalDayOfWeek weekStart = recurrence.GetWeekStart();
1783         CalDayOfWeek weekEnd = CAL_SATURDAY;
1784         DateTime until;
1785         TimeSpan duration = endTime.GetTime() - startTime.GetTime();
1786
1787         if (weekStart == CAL_MONDAY)
1788         {
1789                 weekEnd = CAL_SUNDAY;
1790         }
1791
1792         if (recurrence.GetUntil() != null)
1793         {
1794                 until = *(recurrence.GetUntil());
1795                 if (!isAllDay)
1796                 {
1797                         until = timeZone.UtcTimeToWallTime(until);
1798                 }
1799         }
1800         else
1801         {
1802                 until = _CalendarbookImpl::GetMaxDateTime();
1803         }
1804
1805         CalDayOfWeek dayOfStartTime = GetDayOfWeek(startTime, timeZone);
1806
1807         if (frequency == FREQ_WEEKLY)
1808         {
1809                 int count = 0;
1810
1811                 for (int i = 0; i < _NUMBER_OF_DAYS_OF_WEEK; i++)
1812                 {
1813                         if ((dayOfStartTime & dayOfWeek) != 0)
1814                         {
1815                                 break;
1816                         }
1817
1818                         if ((dayOfStartTime & weekEnd) != 0)
1819                         {
1820                                 count += (interval - 1) * _NUMBER_OF_DAYS_OF_WEEK;
1821                         }
1822
1823                         dayOfStartTime = GetNextDayOfWeek(dayOfStartTime);
1824                         count++;
1825                 }
1826
1827                 result r = calculatedStartTime.AddDays(count);
1828                 SysTryReturnResult(NID_SCL, !IsFailed(r), r, "[%s][Propagating]", GetErrorMessage(r));
1829                 r = calculatedEndTime.AddDays(count);
1830                 SysTryReturnResult(NID_SCL, !IsFailed(r), r, "[%s][Propagating]", GetErrorMessage(r));
1831
1832         }
1833         else if (frequency == FREQ_MONTHLY)
1834         {
1835                 if (dayOfMonth != 0)
1836                 {
1837                         bool isDone = false;
1838                         while (calculatedStartTime <= until)
1839                         {
1840                                 if (calculatedStartTime.SetValue(calculatedStartTime.GetYear(), calculatedStartTime.GetMonth(), dayOfMonth, calculatedStartTime.GetHour(), calculatedStartTime.GetMinute(), calculatedStartTime.GetSecond()) == E_SUCCESS)
1841                                 {
1842                                         if (calculatedStartTime >= startTime)
1843                                         {
1844                                                 isDone = true;
1845                                                 break;
1846                                         }
1847                                 }
1848                                 calculatedStartTime.AddMonths(interval);
1849                         }
1850                         SysTryReturnResult(NID_SCL, isDone, E_INVALID_ARG, "Invalid argument is used. There is no instance of the recurrence.");
1851                         calculatedEndTime = calculatedStartTime;
1852                         calculatedEndTime.Add(duration);
1853                 }
1854                 else
1855                 {
1856                         bool isDone = false;
1857                         int dayCount = 0;
1858                         CalDayOfWeek tmpDayOfWeek = GetFirstDay(weekStart, dayOfWeek, dayCount);
1859                         while (calculatedStartTime <= until)
1860                         {
1861                                 for (int i = 0; i < dayCount; i++)
1862                                 {
1863                                         calculatedStartTime = GetDate(calculatedStartTime.GetYear(), calculatedStartTime.GetMonth(), weekOfMonth, tmpDayOfWeek, calculatedStartTime, timeZone);
1864                                         if (calculatedStartTime >= startTime)
1865                                         {
1866                                                 isDone = true;
1867                                                 break;
1868                                         }
1869                                         tmpDayOfWeek = GetNextDay(dayOfWeek, tmpDayOfWeek);
1870                                 }
1871                                 if (isDone)
1872                                 {
1873                                         break;
1874                                 }
1875                                 calculatedStartTime.AddMonths(interval);
1876                         }
1877
1878                         SysTryReturnResult(NID_SCL, isDone, E_INVALID_ARG, "Invalid argument is used. There is no instance of the recurrence.");
1879                         calculatedEndTime = calculatedStartTime;
1880                         calculatedEndTime.Add(duration);
1881                 }
1882         }
1883         else if (frequency == FREQ_YEARLY)
1884         {
1885                 if (dayOfMonth != 0)
1886                 {
1887                         bool isDone = false;
1888                         while (calculatedStartTime <= until)
1889                         {
1890                                 if (calculatedStartTime.SetValue(calculatedStartTime.GetYear(), monthOfYear, dayOfMonth, calculatedStartTime.GetHour(), calculatedStartTime.GetMinute(), calculatedStartTime.GetSecond()) == E_SUCCESS)
1891                                 {
1892                                         if (calculatedStartTime >= startTime)
1893                                         {
1894                                                 isDone = true;
1895                                                 break;
1896                                         }
1897                                 }
1898                                 calculatedStartTime.AddYears(interval);
1899                         }
1900                         SysTryReturnResult(NID_SCL, isDone, E_INVALID_ARG, "Invalid argument is used. There is no instance of the recurrence.");
1901                         calculatedEndTime = calculatedStartTime;
1902                         calculatedEndTime.Add(duration);
1903                 }
1904                 else
1905                 {
1906                         bool isDone = false;
1907                         int dayCount = 0;
1908                         CalDayOfWeek tmpDayOfWeek = GetFirstDay(weekStart, dayOfWeek, dayCount);
1909                         while (calculatedStartTime <= until)
1910                         {
1911                                 for (int i = 0; i < dayCount; i++)
1912                                 {
1913                                         calculatedStartTime = GetDate(calculatedStartTime.GetYear(), monthOfYear, weekOfMonth, tmpDayOfWeek, calculatedStartTime, timeZone);
1914                                         if (calculatedStartTime >= startTime)
1915                                         {
1916                                                 isDone = true;
1917                                                 break;
1918                                         }
1919                                         tmpDayOfWeek = GetNextDay(dayOfWeek, tmpDayOfWeek);
1920                                 }
1921                                 if (isDone)
1922                                 {
1923                                         break;
1924                                 }
1925                                 calculatedStartTime.AddYears(interval);
1926                         }
1927
1928                         SysTryReturnResult(NID_SCL, isDone, E_INVALID_ARG, "Invalid argument is used. There is no instance of the recurrence.");
1929                         calculatedEndTime = calculatedStartTime;
1930                         calculatedEndTime.Add(duration);
1931                 }
1932         }
1933
1934         if (!isAllDay)
1935         {
1936                 calculatedStartTime = timeZone.WallTimeToUtcTime(calculatedStartTime);
1937                 calculatedEndTime = timeZone.WallTimeToUtcTime(calculatedEndTime);
1938         }
1939
1940         SysTryReturnResult(NID_SCL, calculatedStartTime <= until, E_INVALID_ARG, "Invalid argument is used. There is no instance of the recurrence.");
1941         SysTryReturnResult(NID_SCL, calculatedEndTime <= _CalendarbookImpl::GetMaxDateTime(), E_INVALID_ARG, "Invalid argument is used. There is no instance of the recurrence.");
1942
1943         SysLog(NID_SCL, "Reset start time : %S", calculatedStartTime.ToString().GetPointer());
1944         SetStartAndEndTimeCommon(calculatedStartTime, calculatedEndTime);
1945
1946         return E_SUCCESS;
1947 }
1948
1949 int
1950 _CalEventImpl::ConvertRRuleByDayStringToDayOfWeek(const String& byDay) const
1951 {
1952         int dayOfWeek = 0;
1953         ClearLastResult();
1954
1955         SysTryReturn(NID_SCL, !byDay.IsEmpty(), 0, E_INVALID_ARG, "[%s] Invalid argument is used. The byDay is empty.", GetErrorMessage(E_INVALID_ARG));
1956
1957         String delim(_RECURRENCE_DELIMITER);
1958         String token;
1959
1960         StringTokenizer strTok(byDay, delim);
1961         while (strTok.HasMoreTokens())
1962         {
1963                 result r = strTok.GetNextToken(token);
1964                 SysTryReturn(NID_SCL, r == E_SUCCESS, 0, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1965
1966                 if (token == String(_RECURRENCE_KEYWORD_SUNDAY))
1967                 {
1968                         dayOfWeek |= CAL_SUNDAY;
1969                 }
1970                 else    if (token == String(_RECURRENCE_KEYWORD_MONDAY))
1971                 {
1972                         dayOfWeek |= CAL_MONDAY;
1973                 }
1974                 else    if (token == String(_RECURRENCE_KEYWORD_TUESDAY))
1975                 {
1976                         dayOfWeek |= CAL_TUESDAY;
1977                 }
1978                 else    if (token == String(_RECURRENCE_KEYWORD_WEDNESDAY))
1979                 {
1980                         dayOfWeek |= CAL_WEDNESDAY;
1981                 }
1982                 else    if (token == String(_RECURRENCE_KEYWORD_THURSDAY))
1983                 {
1984                         dayOfWeek |= CAL_THURSDAY;
1985                 }
1986                 else    if (token == String(_RECURRENCE_KEYWORD_FRIDAY))
1987                 {
1988                         dayOfWeek |= CAL_FRIDAY;
1989                 }
1990                 else    if (token == String(_RECURRENCE_KEYWORD_SATURDAY))
1991                 {
1992                         dayOfWeek |= CAL_SATURDAY;
1993                 }
1994                 else
1995                 {
1996                         SysLogException(NID_SCL, E_INVALID_ARG, "[%s] Invalid argument is used. byday = %S", GetErrorMessage(E_INVALID_ARG), byDay.GetPointer());
1997                         return 0;
1998                 }
1999         }
2000
2001         return dayOfWeek;
2002 }
2003
2004 result
2005 _CalEventImpl::ConvertRRuleByDayStringToDayOfWeekAndWeekOfMonth(const String& byDay, int& weekOfMonth, int& dayOfWeek) const
2006 {
2007         String delim(_RECURRENCE_DELIMITER);
2008         String token;
2009         wchar_t tmpChar = 0;
2010         int tmpWeekOfMonth = 0;
2011         int weekStringStartIndex = 0;
2012         String tmpString;
2013
2014         weekOfMonth = 0;
2015         dayOfWeek = 0;
2016
2017         SysTryReturnResult(NID_SCL, !byDay.IsEmpty(), E_INVALID_ARG, "Invalid argument is passed. The byDay is empty.");
2018
2019         StringTokenizer strTok(byDay, delim);
2020
2021         while (strTok.HasMoreTokens())
2022         {
2023                 result r = strTok.GetNextToken(token);
2024                 SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_OUT_OF_MEMORY, "Memory allocation failed.");
2025
2026                 r = token.GetCharAt(_RECURRENCE_BY_DAY_FIRST_INDEX, tmpChar);
2027                 if (tmpChar == _RECURRENCE_BY_DAY_CHAR_MINUS)
2028                 {
2029                         SysTryReturnResult(NID_SCL, weekOfMonth == 0 || weekOfMonth == _MAX_WEEK_OF_MONTH
2030                                         , E_INVALID_ARG, "Invalid argument is passed. byday = %S", byDay.GetPointer());
2031
2032                         if (weekOfMonth == 0)
2033                         {
2034                                 tmpChar = 0;
2035                                 r = token.GetCharAt(_RECURRENCE_BY_DAY_SECOND_INDEX, tmpChar);
2036                                 SysTryReturnResult(NID_SCL, tmpChar == _RECURRENCE_BY_DAY_CHAR_ONE
2037                                                 , E_INVALID_ARG, "Invalid argument is passed. byday = %S", byDay.GetPointer());
2038
2039                                 weekOfMonth = _MAX_WEEK_OF_MONTH;
2040                         }
2041                         weekStringStartIndex = _RECURRENCE_BY_DAY_SECOND_INDEX + 1;
2042                 }
2043                 else if (tmpChar == _RECURRENCE_BY_DAY_CHAR_PLUS)
2044                 {
2045                         if (weekOfMonth == 0)
2046                         {
2047                                 tmpChar = 0;
2048                                 r = token.GetCharAt(_RECURRENCE_BY_DAY_SECOND_INDEX, tmpChar);
2049                                 tmpWeekOfMonth = Character::ToDigit(tmpChar, Character::RADIX_DECIMAL);
2050                                 SysTryReturnResult(NID_SCL, tmpWeekOfMonth > 0 && tmpWeekOfMonth <= _MAX_WEEK_OF_MONTH
2051                                                 , E_INVALID_ARG, "Invalid argument is passed. byday = %S", byDay.GetPointer());
2052
2053                                 weekOfMonth = tmpWeekOfMonth;
2054                         }
2055                         else
2056                         {
2057                                 SysTryReturnResult(NID_SCL, weekOfMonth == tmpWeekOfMonth
2058                                                 , E_INVALID_ARG, "Invalid argument is passed. byday = %S", byDay.GetPointer());
2059                         }
2060
2061                         weekStringStartIndex = _RECURRENCE_BY_DAY_SECOND_INDEX + 1;
2062                 }
2063                 else
2064                 {
2065                         if (weekOfMonth == 0)
2066                         {
2067                                 tmpWeekOfMonth = Character::ToDigit(tmpChar, Character::RADIX_DECIMAL);
2068                                 SysTryReturnResult(NID_SCL, tmpWeekOfMonth > 0 && tmpWeekOfMonth <= _MAX_WEEK_OF_MONTH
2069                                                 , E_INVALID_ARG, "Invalid argument is passed. byday = %S", byDay.GetPointer());
2070
2071                                 weekOfMonth = tmpWeekOfMonth;
2072                         }
2073                         else
2074                         {
2075                                 SysTryReturnResult(NID_SCL, weekOfMonth == tmpWeekOfMonth
2076                                                 , E_INVALID_ARG, "Invalid argument is passed. byday = %S", byDay.GetPointer());
2077                         }
2078
2079                         weekStringStartIndex = _RECURRENCE_BY_DAY_FIRST_INDEX + 1;
2080                 }
2081
2082                 token.SubString(weekStringStartIndex, tmpString);
2083
2084                 if (tmpString == String(_RECURRENCE_KEYWORD_SUNDAY))
2085                 {
2086                         dayOfWeek |= CAL_SUNDAY;
2087                 }
2088                 else    if (tmpString == String(_RECURRENCE_KEYWORD_MONDAY))
2089                 {
2090                         dayOfWeek |= CAL_MONDAY;
2091                 }
2092                 else    if (tmpString == String(_RECURRENCE_KEYWORD_TUESDAY))
2093                 {
2094                         dayOfWeek |= CAL_TUESDAY;
2095                 }
2096                 else    if (tmpString == String(_RECURRENCE_KEYWORD_WEDNESDAY))
2097                 {
2098                         dayOfWeek |= CAL_WEDNESDAY;
2099                 }
2100                 else    if (tmpString == String(_RECURRENCE_KEYWORD_THURSDAY))
2101                 {
2102                         dayOfWeek |= CAL_THURSDAY;
2103                 }
2104                 else    if (tmpString == String(_RECURRENCE_KEYWORD_FRIDAY))
2105                 {
2106                         dayOfWeek |= CAL_FRIDAY;
2107                 }
2108                 else    if (tmpString == String(_RECURRENCE_KEYWORD_SATURDAY))
2109                 {
2110                         dayOfWeek |= CAL_SATURDAY;
2111                 }
2112                 else
2113                 {
2114                         SysLogException(NID_SCL, E_INVALID_ARG, "[%s] Invalid argument is used. byday = %S", GetErrorMessage(E_INVALID_ARG), byDay.GetPointer());
2115                 }
2116         }
2117
2118         return E_SUCCESS;
2119 }
2120
2121 result
2122 _CalEventImpl::ConvertRRuleExDateStringToRecurrence(const String& exdate, Recurrence& recurrence) const
2123 {
2124         String delim(_RECURRENCE_DELIMITER);
2125         String token;
2126         DateTime tmpDateTime;
2127         TimeZone tmpTimeZone;
2128         TimeZone utcTimeZone = TimeZone::GetGmtTimeZone();
2129         bool isDate = false;
2130
2131         SysTryReturnResult(NID_SCL, !exdate.IsEmpty(), E_INVALID_ARG, "Invalid argument is passed. The exdate is empty.");
2132
2133         StringTokenizer strTok(exdate, delim);
2134         while (strTok.HasMoreTokens())
2135         {
2136                 result r = strTok.GetNextToken(token);
2137                 SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_OUT_OF_MEMORY, "Memory allocation failed.");
2138
2139                 r = _CalendarbookUtil::ConvertRRuleDateTimeStringToDateTime(token, tmpDateTime, tmpTimeZone, isDate);
2140                 SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_INVALID_ARG, "Invalid argument is passed. exdate = %S", exdate.GetPointer());
2141
2142                 if (!isDate && tmpTimeZone != utcTimeZone)
2143                 {
2144                         tmpDateTime = tmpTimeZone.WallTimeToUtcTime(tmpDateTime);
2145                 }
2146
2147                 r = recurrence.AddExceptionDate(tmpDateTime);
2148                 SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_INVALID_ARG, "Invalid argument is passed. exdate = %S", exdate.GetPointer());
2149         }
2150
2151         return E_SUCCESS;
2152 }
2153
2154 String
2155 _CalEventImpl::ConvertRecurrenceToRRuleExDateString(const Recurrence& recurrence, bool isDate) const
2156 {
2157         bool isNotFirst = false;
2158         String exdateString;
2159
2160         std::unique_ptr<IList, AllElementsDeleter> pExDateList(recurrence.GetExceptionDatesN());
2161
2162         std::unique_ptr<IEnumerator> pEnum(pExDateList->GetEnumeratorN());
2163         while (pEnum->MoveNext() == E_SUCCESS)
2164         {
2165                 DateTime* pDateTime = static_cast<DateTime*>(pEnum->GetCurrent());
2166
2167                 if (isNotFirst)
2168                 {
2169                         exdateString.Append(_RECURRENCE_DELIMITER);
2170                 }
2171
2172                 exdateString.Append(_CalendarbookUtil::ConvertDateTimeToRRuleDateTimeString(*pDateTime, isDate));
2173
2174                 isNotFirst = true;
2175         }
2176
2177         return exdateString;
2178 }
2179
2180 CalDayOfWeek
2181 _CalEventImpl::GetNextDayOfWeek(CalDayOfWeek currentDay)
2182 {
2183         int tmpDay = currentDay;
2184
2185         tmpDay <<= 1;
2186         if (tmpDay > CAL_SATURDAY)
2187         {
2188                 tmpDay = CAL_SUNDAY;
2189         }
2190
2191         return static_cast<CalDayOfWeek>(tmpDay);
2192 }
2193
2194 DateTime
2195 _CalEventImpl::GetDate(int year, int month, int weekOfMonth, CalDayOfWeek dayOfWeek, const DateTime& time, const TimeZone& timeZone)
2196 {
2197         ClearLastResult();
2198
2199         Tizen::Locales::DayOfWeek dayOfWeekByGregorianCalendar = Tizen::Locales::DAY_OF_WEEK_UNDEFINED;
2200
2201         switch (dayOfWeek)
2202         {
2203         case CAL_SUNDAY:
2204                 dayOfWeekByGregorianCalendar = Tizen::Locales::SUNDAY;
2205                 break;
2206
2207         case CAL_MONDAY:
2208                 dayOfWeekByGregorianCalendar = Tizen::Locales::MONDAY;
2209                 break;
2210
2211         case CAL_TUESDAY:
2212                 dayOfWeekByGregorianCalendar = Tizen::Locales::TUESDAY;
2213                 break;
2214
2215         case CAL_WEDNESDAY:
2216                 dayOfWeekByGregorianCalendar = Tizen::Locales::WEDNESDAY;
2217                 break;
2218
2219         case CAL_THURSDAY:
2220                 dayOfWeekByGregorianCalendar = Tizen::Locales::THURSDAY;
2221                 break;
2222
2223         case CAL_FRIDAY:
2224                 dayOfWeekByGregorianCalendar = Tizen::Locales::FRIDAY;
2225                 break;
2226
2227         case CAL_SATURDAY:
2228                 dayOfWeekByGregorianCalendar = Tizen::Locales::SATURDAY;
2229                 break;
2230
2231         default:
2232                 break;
2233         }
2234
2235         std::unique_ptr<Tizen::Locales::Calendar> pGregorianCalendar(Tizen::Locales::Calendar::CreateInstanceN(timeZone, Tizen::Locales::CALENDAR_GREGORIAN));
2236         SysTryReturn(NID_SCL, pGregorianCalendar != null, DateTime(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
2237
2238         pGregorianCalendar->SetTimeField(Tizen::Locales::TIME_FIELD_YEAR, year);
2239         pGregorianCalendar->SetTimeField(Tizen::Locales::TIME_FIELD_MONTH, month);
2240         pGregorianCalendar->SetTimeField(Tizen::Locales::TIME_FIELD_DAY_OF_MONTH, 1);
2241
2242         Tizen::Locales::DayOfWeek tmpDayOfWeek = static_cast<Tizen::Locales::DayOfWeek>(pGregorianCalendar->GetTimeField(TIME_FIELD_DAY_OF_WEEK));
2243         int maxDaysOfMonth = pGregorianCalendar->GetActualMaxTimeField(TIME_FIELD_DAY_OF_MONTH);
2244         int tmpDayOfMonth = ((_NUMBER_OF_DAYS_OF_WEEK + dayOfWeekByGregorianCalendar) - tmpDayOfWeek) % _NUMBER_OF_DAYS_OF_WEEK + 1;
2245
2246         tmpDayOfMonth += ((weekOfMonth - 1) * _NUMBER_OF_DAYS_OF_WEEK);
2247         if (tmpDayOfMonth > maxDaysOfMonth)
2248         {
2249                 tmpDayOfMonth -= _NUMBER_OF_DAYS_OF_WEEK;
2250         }
2251
2252         DateTime resultTime;
2253         resultTime.SetValue(year, month, tmpDayOfMonth, time.GetHour(), time.GetMinute(), time.GetSecond());
2254
2255         return resultTime;
2256 }
2257
2258 CalDayOfWeek
2259 _CalEventImpl::GetDayOfWeek(const DateTime& date, const Locales::TimeZone& timeZone)
2260 {
2261         ClearLastResult();
2262
2263         CalDayOfWeek dayOfWeek = CAL_SUNDAY;
2264
2265         std::unique_ptr<Tizen::Locales::Calendar> pGregorianCalendar(Tizen::Locales::Calendar::CreateInstanceN(timeZone, Tizen::Locales::CALENDAR_GREGORIAN));
2266         SysTryReturn(NID_SCL, pGregorianCalendar != null, dayOfWeek, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
2267
2268         pGregorianCalendar->SetTime(date);
2269         int dayOfWeekByGregorianCalendar = pGregorianCalendar->GetTimeField(Tizen::Locales::TIME_FIELD_DAY_OF_WEEK);
2270
2271         switch (dayOfWeekByGregorianCalendar)
2272         {
2273         case Tizen::Locales::SUNDAY:
2274                 dayOfWeek = CAL_SUNDAY;
2275                 break;
2276
2277         case Tizen::Locales::MONDAY:
2278                 dayOfWeek = CAL_MONDAY;
2279                 break;
2280
2281         case Tizen::Locales::TUESDAY:
2282                 dayOfWeek = CAL_TUESDAY;
2283                 break;
2284
2285         case Tizen::Locales::WEDNESDAY:
2286                 dayOfWeek = CAL_WEDNESDAY;
2287                 break;
2288
2289         case Tizen::Locales::THURSDAY:
2290                 dayOfWeek = CAL_THURSDAY;
2291                 break;
2292
2293         case Tizen::Locales::FRIDAY:
2294                 dayOfWeek = CAL_FRIDAY;
2295                 break;
2296
2297         case Tizen::Locales::SATURDAY:
2298                 dayOfWeek = CAL_SATURDAY;
2299                 break;
2300
2301         default:
2302                 break;
2303         }
2304
2305         return dayOfWeek;
2306 }
2307
2308 CalDayOfWeek
2309 _CalEventImpl::GetFirstDay(CalDayOfWeek weekStart, int dayOfWeek, int& count)
2310 {
2311         int firstDay = 0;
2312         int tmpDay = weekStart;
2313
2314         count = 0;
2315         for (int i = 0; i < _NUMBER_OF_DAYS_OF_WEEK; i++)
2316         {
2317                 if ((tmpDay & dayOfWeek) != 0)
2318                 {
2319                         if (firstDay == 0)
2320                         {
2321                                 firstDay = tmpDay;
2322                         }
2323
2324                         count++;
2325                 }
2326
2327                 tmpDay = GetNextDayOfWeek(static_cast<CalDayOfWeek>(tmpDay));
2328         }
2329
2330         return static_cast<CalDayOfWeek>(firstDay);
2331 }
2332
2333 CalDayOfWeek
2334 _CalEventImpl::GetNextDay(int dayOfWeek, CalDayOfWeek currentDay)
2335 {
2336         int tmpDay = currentDay;
2337
2338         for (int i = 0; i < _NUMBER_OF_DAYS_OF_WEEK; i++)
2339         {
2340                 tmpDay = GetNextDayOfWeek(static_cast<CalDayOfWeek>(tmpDay));
2341
2342                 if ((tmpDay & dayOfWeek) != 0)
2343                 {
2344                         break;
2345                 }
2346         }
2347
2348         return static_cast<CalDayOfWeek>(tmpDay);
2349 }
2350
2351 void
2352 _CalEventImpl::SetRecordHandle(calendar_record_h eventHandle)
2353 {
2354         __eventRecord.ResetHandle(eventHandle);
2355 }
2356
2357 calendar_record_h
2358 _CalEventImpl::GetRecordHandle(void) const
2359 {
2360         return __eventRecord.GetHandle();
2361 }
2362
2363 CalEvent*
2364 _CalEventImpl::CreateDefaultInstanceN(void)
2365 {
2366         return new (std::nothrow) CalEvent();
2367 }
2368
2369 _CalEventImpl*
2370 _CalEventImpl::GetInstance(CalEvent& event)
2371 {
2372         return event.__pCalEventImpl;
2373 }
2374
2375 const _CalEventImpl*
2376 _CalEventImpl::GetInstance(const CalEvent& event)
2377 {
2378         return event.__pCalEventImpl;
2379 }
2380
2381 }} //Tizen::Social