src/FScl_CalTodoImpl.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_CalTodoImpl.cpp
  18  * @brief               This is the implementation for _CalTodoImpl class.
  19  *
  20  * This file contains definitions of @e CalTodoImpl class.
  21  */
  22
  23 #include <FBaseDateTime.h>
  24 #include <FBaseColArrayList.h>
  25 #include <FSysSystemTime.h>
  26 #include <FSclTypes.h>
  27 #include <FSclRecord.h>
  28 #include <FSclCalTodo.h>
  29 #include <FSclReminder.h>
  30 #include <FSclRecurrence.h>
  31 #include <FBaseSysLog.h>
  32 #include <FApp_AppInfo.h>
  33 #include <FBase_StringConverter.h>
  34 #include "FScl_CalTodoImpl.h"
  35 #include "FScl_RecordImpl.h"
  36 #include "FScl_CalendarbookImpl.h"
  37 #include "FScl_CalendarbookDbConnector.h"
  38
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Base::Collection;
  41 using namespace Tizen::App;
  42
  43 namespace Tizen { namespace Social
  44 {
  45 static const double _MIN_LATITUDE = -90.0;
  46 static const double _MAX_LATITUDE = 90.0;
  47 static const double _MIN_LONGITUDE = -180.0;
  48 static const double _MAX_LONGITUDE = 180.0;
  49
  50 static const long long _CALENDAR_TODO_NO_START_DATE = -0x7fffffffffffffffLL;
  51 static const long long _CALENDAR_TODO_NO_DUE_DATE = 0x7fffffffffffffffLL;
  52
  53 _CalTodoImpl::_CalTodoImpl(void)
  54         : __reminderListUpdated(false)
  55 {
  56         int errorCode = CALENDAR_ERROR_NONE;
  57         calendar_record_h todoHandle = null;
  58
  59         result r = _CalendarbookDbConnector::Connect();
  60         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
  61
  62         errorCode = calendar_record_create(_calendar_todo._uri, &todoHandle);
  63         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  64
  65         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
  66         {
  67                 DateTime tmpDateTime;
  68
  69                 // Set start date to current date
  70                 Tizen::System::SystemTime::GetCurrentTime(tmpDateTime);
  71                 if (IsFailed(GetLastResult()))
  72                 {
  73                         tmpDateTime = _CalendarbookImpl::GetMinDateTime();
  74                         ClearLastResult();
  75                 }
  76                 tmpDateTime.SetValue(tmpDateTime.GetYear(), tmpDateTime.GetMonth(), tmpDateTime.GetDay(), 0, 0, 0);
  77
  78                 calendar_time_s convertedCalendarTime;
  79
  80                 convertedCalendarTime.type = CALENDAR_TIME_UTIME;
  81                 convertedCalendarTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(tmpDateTime);
  82
  83                 calendar_record_set_caltime(todoHandle, _calendar_todo.start_time, convertedCalendarTime);
  84                 calendar_record_set_caltime(todoHandle, _calendar_todo.due_time, convertedCalendarTime);
  85         }
  86         else
  87         {
  88                 calendar_time_s convertedStartTime;
  89                 convertedStartTime.type = CALENDAR_TIME_UTIME;
  90                 convertedStartTime.time.utime = _CALENDAR_TODO_NO_START_DATE;
  91
  92                 calendar_time_s convertedDueTime;
  93                 convertedDueTime.type = CALENDAR_TIME_UTIME;
  94                 convertedDueTime.time.utime = _CALENDAR_TODO_NO_DUE_DATE;
  95
  96                 calendar_record_set_caltime(todoHandle, _calendar_todo.start_time, convertedStartTime);
  97                 calendar_record_set_caltime(todoHandle, _calendar_todo.due_time, convertedDueTime);
  98         }
  99
 100         // default value
 101         calendar_record_set_int(todoHandle, _calendar_todo.todo_status, CALENDAR_TODO_STATUS_NONE);
 102         calendar_record_set_int(todoHandle, _calendar_todo.priority, CALENDAR_TODO_PRIORITY_NORMAL);
 103         calendar_record_set_int(todoHandle, _calendar_todo.sensitivity, CALENDAR_SENSITIVITY_PUBLIC);
 104
 105         __todoRecord.ResetHandle(todoHandle);
 106
 107         r = __reminderList.Construct();
 108         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 109 }
 110
 111 _CalTodoImpl::_CalTodoImpl(const _CalTodoImpl& rhs)
 112         : __reminderListUpdated(false)
 113 {
 114         int errorCode = CALENDAR_ERROR_NONE;
 115         calendar_record_h todoHandle = null;
 116
 117         result r = _CalendarbookDbConnector::Connect();
 118         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
 119
 120         errorCode = calendar_record_clone(rhs.__todoRecord.GetHandle(), &todoHandle);
 121         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 122
 123         __todoRecord.ResetHandle(todoHandle);
 124
 125         r = __reminderList.Construct();
 126         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 127 }
 128
 129 _CalTodoImpl::~_CalTodoImpl(void)
 130 {
 131         __reminderList.RemoveAll(true);
 132
 133         result r = _CalendarbookDbConnector::Disconnect();
 134         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
 135 }
 136
 137 _CalTodoImpl&
 138 _CalTodoImpl::operator =(const _CalTodoImpl& rhs)
 139 {
 140         if (this == &rhs)
 141         {
 142                 return *this;
 143         }
 144
 145         __reminderList.RemoveAll(true);
 146         __reminderListUpdated = false;
 147
 148         int errorCode = CALENDAR_ERROR_NONE;
 149         calendar_record_h todoHandle = null;
 150
 151         errorCode = calendar_record_clone(rhs.__todoRecord.GetHandle(), &todoHandle);
 152         SysTryReturn(NID_SCL, errorCode == CALENDAR_ERROR_NONE, *this, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 153
 154         __todoRecord.ResetHandle(todoHandle);
 155
 156         return *this;
 157 }
 158
 159 String
 160 _CalTodoImpl::GetSubject(void) const
 161 {
 162         char* pSubject = null;
 163
 164         calendar_record_get_str_p(__todoRecord.GetHandle(), _calendar_todo.summary, &pSubject);
 165
 166         return String(pSubject);
 167 }
 168
 169 String
 170 _CalTodoImpl::GetDescription(void) const
 171 {
 172         char* pDescription = null;
 173
 174         calendar_record_get_str_p(__todoRecord.GetHandle(), _calendar_todo.description, &pDescription);
 175
 176         return String(pDescription);
 177 }
 178
 179 DateTime
 180 _CalTodoImpl::GetStartDate(void) const
 181 {
 182         ClearLastResult();
 183
 184         calendar_time_s tmpCalendarTime;
 185
 186         calendar_record_get_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, &tmpCalendarTime);
 187
 188         if (tmpCalendarTime.time.utime == _CALENDAR_TODO_NO_START_DATE)
 189         {
 190                 SetLastResult(E_DATA_NOT_FOUND);
 191                 return DateTime::GetMinValue();
 192         }
 193
 194         DateTime tmpDateTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(tmpCalendarTime.time.utime);
 195
 196         return tmpDateTime;
 197 }
 198
 199 DateTime
 200 _CalTodoImpl::GetDueDate(void) const
 201 {
 202         ClearLastResult();
 203
 204         calendar_time_s tmpCalendarTime;
 205
 206         calendar_record_get_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, &tmpCalendarTime);
 207
 208         if (tmpCalendarTime.time.utime == _CALENDAR_TODO_NO_DUE_DATE)
 209         {
 210                 SetLastResult(E_DATA_NOT_FOUND);
 211                 return DateTime::GetMinValue();
 212         }
 213
 214         DateTime tmpDateTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(tmpCalendarTime.time.utime);
 215
 216         return tmpDateTime;
 217 }
 218
 219 TodoPriority
 220 _CalTodoImpl::GetPriority(void) const
 221 {
 222         int srcPriority = CALENDAR_EVENT_PRIORITY_LOW;
 223
 224         TodoPriority priority = TODO_PRIORITY_NORMAL;
 225
 226         calendar_record_get_int(__todoRecord.GetHandle(), _calendar_todo.priority, &srcPriority);
 227
 228         switch (srcPriority)
 229         {
 230         case CALENDAR_TODO_PRIORITY_LOW:
 231                 priority = TODO_PRIORITY_LOW;
 232                 break;
 233         case CALENDAR_TODO_PRIORITY_NONE:
 234                 // fall through
 235         case CALENDAR_TODO_PRIORITY_NORMAL:
 236                 priority = TODO_PRIORITY_NORMAL;
 237                 break;
 238         case CALENDAR_TODO_PRIORITY_HIGH:
 239                 priority = TODO_PRIORITY_HIGH;
 240                 break;
 241         default:
 242                 SysLog(NID_SCL, "The priority value is invalid. priority = %d", srcPriority);
 243                 priority = TODO_PRIORITY_NORMAL;
 244                 break;
 245         }
 246
 247         return priority;
 248 }
 249
 250 TodoStatus
 251 _CalTodoImpl::GetStatus(void) const
 252 {
 253         int srcStatus = CALENDAR_EVENT_STATUS_NONE;
 254
 255         TodoStatus status = TODO_STATUS_NONE;
 256
 257         calendar_record_get_int(__todoRecord.GetHandle(), _calendar_todo.todo_status, &srcStatus);
 258
 259         switch (srcStatus)
 260         {
 261         case CALENDAR_TODO_STATUS_NONE:
 262                 status = TODO_STATUS_NONE;
 263                 break;
 264         case CALENDAR_TODO_STATUS_NEEDS_ACTION:
 265                 status = TODO_STATUS_NEEDS_ACTION;
 266                 break;
 267         case CALENDAR_TODO_STATUS_COMPLETED:
 268                 status = TODO_STATUS_COMPLETED;
 269                 break;
 270         case CALENDAR_TODO_STATUS_IN_PROCESS:
 271                 status = TODO_STATUS_IN_PROCESS;
 272                 break;
 273         case CALENDAR_TODO_STATUS_CANCELED:
 274                 status = TODO_STATUS_CANCELLED;
 275                 break;
 276         default:
 277                 SysLog(NID_SCL, "The status value is invalid. status = %d", srcStatus);
 278                 status = TODO_STATUS_NONE;
 279                 break;
 280         }
 281
 282         return status;
 283 }
 284
 285 RecordSensitivity
 286 _CalTodoImpl::GetSensitivity(void) const
 287 {
 288         int srcSensitivity = CALENDAR_SENSITIVITY_PUBLIC;
 289         RecordSensitivity sensitivity = SENSITIVITY_PUBLIC;
 290
 291         calendar_record_get_int(__todoRecord.GetHandle(), _calendar_todo.sensitivity, &srcSensitivity);
 292
 293         switch (srcSensitivity)
 294         {
 295         case CALENDAR_SENSITIVITY_PUBLIC:
 296                 sensitivity = SENSITIVITY_PUBLIC;
 297                 break;
 298         case CALENDAR_SENSITIVITY_PRIVATE:
 299                 sensitivity = SENSITIVITY_PRIVATE;
 300                 break;
 301         case CALENDAR_SENSITIVITY_CONFIDENTIAL:
 302                 sensitivity = SENSITIVITY_CONFIDENTIAL;
 303                 break;
 304         default:
 305                 SysLog(NID_SCL, "The sensitivity value is invalid. sensitivity = %d", srcSensitivity);
 306                 sensitivity = SENSITIVITY_PUBLIC;
 307                 break;
 308         }
 309
 310         return sensitivity;
 311 }
 312
 313 DateTime
 314 _CalTodoImpl::GetLastRevisedTime(void) const
 315 {
 316         long long lastModifiedTime = 0;
 317         DateTime tmpLastRevisedTime;
 318
 319         calendar_record_get_lli(__todoRecord.GetHandle(), _calendar_todo.last_modified_time, &lastModifiedTime);
 320
 321         tmpLastRevisedTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(lastModifiedTime);
 322
 323         return tmpLastRevisedTime;
 324 }
 325
 326 result
 327 _CalTodoImpl::SetSubject(const String& subject)
 328 {
 329         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
 330         {
 331                 SysTryReturnResult(NID_SCL, subject.GetLength() <= MAX_TODO_SUBJECT_LENGTH,
 332                                         E_INVALID_ARG, "Invalid argument is used. The length of the subject exceeds MAX_TODO_SUBJECT_LENGTH.");
 333         }
 334
 335         std::unique_ptr<char[]> pConvertedSubject(_StringConverter::CopyToCharArrayN(subject));
 336         SysTryReturnResult(NID_SCL, pConvertedSubject != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 337
 338         int errorCode = CALENDAR_ERROR_NONE;
 339         errorCode = calendar_record_set_str(__todoRecord.GetHandle(), _calendar_todo.summary, pConvertedSubject.get());
 340         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 341
 342         return E_SUCCESS;
 343 }
 344
 345 result
 346 _CalTodoImpl::SetDescription(const String& description)
 347 {
 348         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
 349         {
 350                 SysTryReturnResult(NID_SCL, description.GetLength() <= MAX_TODO_DESCRIPTION_LENGTH,
 351                                         E_INVALID_ARG, "Invalid argument is used. The length of the description exceeds MAX_TODO_SUBJECT_LENGTH.");
 352         }
 353
 354         std::unique_ptr<char[]> pConvertedDescription(_StringConverter::CopyToCharArrayN(description));
 355         SysTryReturnResult(NID_SCL, pConvertedDescription != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 356
 357         int errorCode = CALENDAR_ERROR_NONE;
 358         errorCode = calendar_record_set_str(__todoRecord.GetHandle(), _calendar_todo.description, pConvertedDescription.get());
 359         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 360
 361         return E_SUCCESS;
 362 }
 363
 364 result
 365 _CalTodoImpl::SetStartAndDueDate(const DateTime& startDate, const DateTime& dueDate)
 366 {
 367         SysTryReturnResult(NID_SCL, _CalendarbookUtil::CheckValidDateTime(startDate), E_INVALID_ARG, "Invalid argument is used. The start date is invalid.");
 368         SysTryReturnResult(NID_SCL, _CalendarbookUtil::CheckValidDateTime(dueDate), E_INVALID_ARG, "Invalid argument is used. The end date is invalid.");
 369         SysTryReturnResult(NID_SCL, startDate <= dueDate, E_INVALID_ARG, "Invalid argument is used. The end date is earlier than the start date.");
 370
 371         calendar_time_s convertedStartTime;
 372         calendar_time_s convertedDueTime;
 373
 374         convertedStartTime.type = CALENDAR_TIME_UTIME;
 375         convertedStartTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(startDate);
 376         convertedDueTime.type = CALENDAR_TIME_UTIME;
 377         convertedDueTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(dueDate);
 378
 379         calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, convertedStartTime);
 380         calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, convertedDueTime);
 381
 382         return E_SUCCESS;
 383 }
 384
 385 result
 386 _CalTodoImpl::SetStartDate(const DateTime& startDate)
 387 {
 388         calendar_time_s convertedStartTime;
 389         convertedStartTime.type = CALENDAR_TIME_UTIME;
 390
 391         if (startDate == DateTime::GetMinValue())
 392         {
 393                 convertedStartTime.time.utime = _CALENDAR_TODO_NO_START_DATE;
 394         }
 395         else if (startDate < _CalendarbookImpl::GetMinDateTime() || startDate > _CalendarbookImpl::GetMaxDateTime())
 396         {
 397                 SysLogException(NID_SCL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used.  The startDate is invalid.");
 398                 return E_INVALID_ARG;
 399         }
 400         else
 401         {
 402                 calendar_time_s convertedDueTime;
 403                 calendar_record_get_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, &convertedDueTime);
 404
 405                 convertedStartTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(startDate);
 406
 407                 if (convertedStartTime.time.utime > convertedDueTime.time.utime)
 408                 {
 409                         convertedDueTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(DateTime::GetMinValue());
 410                         calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, convertedDueTime);
 411                 }
 412         }
 413
 414         calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, convertedStartTime);
 415
 416         return E_SUCCESS;
 417 }
 418
 419 result
 420 _CalTodoImpl::SetDueDate(const DateTime& dueDate)
 421 {
 422         calendar_time_s convertedDueTime;
 423         convertedDueTime.type = CALENDAR_TIME_UTIME;
 424
 425         if (dueDate == DateTime::GetMinValue())
 426         {
 427                 convertedDueTime.time.utime = _CALENDAR_TODO_NO_DUE_DATE;
 428         }
 429         else if (dueDate < _CalendarbookImpl::GetMinDateTime() || dueDate > _CalendarbookImpl::GetMaxDateTime())
 430         {
 431                 SysLogException(NID_SCL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used.  The dueDate is invalid.");
 432                 return E_INVALID_ARG;
 433         }
 434         else
 435         {
 436                 calendar_time_s convertedStartTime;
 437                 calendar_record_get_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, &convertedStartTime);
 438
 439                 convertedDueTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(dueDate);
 440
 441                 if (convertedStartTime.time.utime > convertedDueTime.time.utime)
 442                 {
 443                         convertedStartTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(DateTime::GetMinValue());
 444                         calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, convertedStartTime);
 445                 }
 446         }
 447
 448         calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, convertedDueTime);
 449
 450         return E_SUCCESS;
 451 }
 452
 453 void
 454 _CalTodoImpl::SetPriority(TodoPriority priority)
 455 {
 456         calendar_record_set_int(__todoRecord.GetHandle(), _calendar_todo.priority, _CalendarbookUtil::ConvertTodoPriorityToCSTodoPriority(priority));
 457 }
 458
 459 void
 460 _CalTodoImpl::SetStatus(TodoStatus status)
 461 {
 462         calendar_record_set_int(__todoRecord.GetHandle(), _calendar_todo.todo_status, _CalendarbookUtil::ConvertTodoStatusToCSTodoStatus(status));
 463 }
 464
 465 void
 466 _CalTodoImpl::SetSensitivity(RecordSensitivity sensitivity)
 467 {
 468         calendar_record_set_int(__todoRecord.GetHandle(), _calendar_todo.sensitivity, _CalendarbookUtil::ConvertSensitivityToCSSensitivity(sensitivity));
 469 }
 470
 471 void
 472 _CalTodoImpl::SetLocation(const String& location)
 473 {
 474         std::unique_ptr<char[]> pConvertedLocation(_StringConverter::CopyToCharArrayN(location));
 475         SysTryReturnVoidResult(NID_SCL, pConvertedLocation != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 476
 477         int errorCode = CALENDAR_ERROR_NONE;
 478         errorCode = calendar_record_set_str(__todoRecord.GetHandle(), _calendar_todo.location, pConvertedLocation.get());
 479         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 480 }
 481
 482 String
 483 _CalTodoImpl::GetLocation(void) const
 484 {
 485         char* pLocation = null;
 486
 487         calendar_record_get_str_p(__todoRecord.GetHandle(), _calendar_todo.location, &pLocation);
 488
 489         return String(pLocation);
 490 }
 491
 492 result
 493 _CalTodoImpl::SetCoordinates(double latitude, double longitude)
 494 {
 495         SysTryReturnResult(NID_SCL, latitude >= _MIN_LATITUDE && latitude <= _MAX_LATITUDE, E_INVALID_ARG, "Invalid argument is used. The latitude is out of range.");
 496         SysTryReturnResult(NID_SCL, longitude >= _MIN_LONGITUDE && longitude <= _MAX_LONGITUDE, E_INVALID_ARG, "Invalid argument is used. The longitude is out of range.");
 497
 498         calendar_record_set_double(__todoRecord.GetHandle(), _calendar_todo.latitude, latitude);
 499         calendar_record_set_double(__todoRecord.GetHandle(), _calendar_todo.longitude, longitude);
 500
 501         return E_SUCCESS;
 502 }
 503
 504 void
 505 _CalTodoImpl::GetCoordinates(double& latitude, double& longitude) const
 506 {
 507         calendar_record_get_double(__todoRecord.GetHandle(), _calendar_todo.latitude, &latitude);
 508         calendar_record_get_double(__todoRecord.GetHandle(), _calendar_todo.longitude, &longitude);
 509 }
 510
 511 result
 512 _CalTodoImpl::AddReminder(const Reminder& reminder)
 513 {
 514         int errorCode = CALENDAR_ERROR_NONE;
 515         calendar_record_h tmpAlarmHandle = null;
 516
 517         std::unique_ptr<char[]> pTmpAlarmTone(_StringConverter::CopyToCharArrayN(reminder.GetSoundFile()));
 518         SysTryReturnResult(NID_SCL, pTmpAlarmTone != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 519
 520         errorCode = calendar_record_create(_calendar_alarm._uri, &tmpAlarmHandle);
 521         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 522
 523         int convertedTimeUnit = 0;
 524
 525         ReminderTimeUnit timeUnit = reminder.GetTimeUnit();
 526         switch (timeUnit)
 527         {
 528         case REMINDER_TIME_UNIT_MINUTE:
 529                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_MINUTE;
 530                 break;
 531         case REMINDER_TIME_UNIT_HOUR:
 532                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_HOUR;
 533                 break;
 534         case REMINDER_TIME_UNIT_DAY:
 535                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_DAY;
 536                 break;
 537         case REMINDER_TIME_UNIT_WEEK:
 538                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_WEEK;
 539                 break;
 540         case REMINDER_TIME_UNIT_NONE:
 541                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_SPECIFIC;
 542                 break;
 543         default:
 544                 break;
 545         }
 546
 547         calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick_unit, convertedTimeUnit);
 548         calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick, reminder.GetTimeOffset());
 549         errorCode = calendar_record_set_str(tmpAlarmHandle, _calendar_alarm.tone, pTmpAlarmTone.get());
 550         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 551
 552         if (convertedTimeUnit == CALENDAR_ALARM_TIME_UNIT_SPECIFIC)
 553         {
 554                 calendar_record_set_lli(tmpAlarmHandle, _calendar_alarm.time, _CalendarbookUtil::ConvertDateTimeToEpochTime(reminder.GetAbsoluteTime()));
 555         }
 556
 557         errorCode = calendar_record_add_child_record(__todoRecord.GetHandle(), _calendar_todo.calendar_alarm, tmpAlarmHandle);
 558         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 559
 560         __reminderList.RemoveAll(true);
 561         __reminderListUpdated = false;
 562
 563         return E_SUCCESS;
 564 }
 565
 566 result
 567 _CalTodoImpl::RemoveReminderAt(int index)
 568 {
 569         int errorCode = CALENDAR_ERROR_NONE;
 570         calendar_record_h tmpAlarmHandle = null;
 571
 572         errorCode = calendar_record_get_child_record_at_p(__todoRecord.GetHandle(), _calendar_todo.calendar_alarm, index, &tmpAlarmHandle);
 573         SysTryReturnResult(NID_SCL, tmpAlarmHandle != null, E_OUT_OF_RANGE, "The index is either equal to or greater than the number of reminders or less than 0.");
 574
 575         calendar_record_remove_child_record(__todoRecord.GetHandle(), _calendar_todo.calendar_alarm, tmpAlarmHandle);
 576
 577         __reminderList.RemoveAll(true);
 578         __reminderListUpdated = false;
 579
 580         return E_SUCCESS;
 581 }
 582
 583 const IList&
 584 _CalTodoImpl::GetAllReminders(void) const
 585 {
 586         ClearLastResult();
 587
 588         if (__reminderListUpdated == false)
 589         {
 590                 result r = _CalendarbookUtil::ConvertTodoAlarmsToReminderList(__todoRecord.GetHandle(), __reminderList);
 591                 SysTryReturn(NID_SCL, r == E_SUCCESS, __reminderList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 592
 593                 __reminderListUpdated = true;
 594         }
 595
 596         return __reminderList;
 597 }
 598
 599 RecordId
 600 _CalTodoImpl::GetCalendarId(void) const
 601 {
 602         int srcCalendarbookId = 0;
 603
 604         calendar_record_get_int(__todoRecord.GetHandle(), _calendar_todo.calendar_book_id, &srcCalendarbookId);
 605
 606         return srcCalendarbookId;
 607 }
 608
 609 void
 610 _CalTodoImpl::SetRecordHandle(calendar_record_h todoHandle)
 611 {
 612         __todoRecord.ResetHandle(todoHandle);
 613 }
 614
 615 calendar_record_h
 616 _CalTodoImpl::GetRecordHandle(void) const
 617 {
 618         return __todoRecord.GetHandle();
 619 }
 620
 621 CalTodo*
 622 _CalTodoImpl::CreateDefaultInstanceN(void)
 623 {
 624         return new (std::nothrow) CalTodo();
 625 }
 626
 627 _CalTodoImpl*
 628 _CalTodoImpl::GetInstance(CalTodo& todo)
 629 {
 630         return todo.__pCalTodoImpl;
 631 }
 632
 633 const _CalTodoImpl*
 634 _CalTodoImpl::GetInstance(const CalTodo& todo)
 635 {
 636         return todo.__pCalTodoImpl;
 637 }
 638
 639 }}      //OSP::Social