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                 r = 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                 errorCode = calendar_record_set_caltime(todoHandle, _calendar_todo.start_time, convertedCalendarTime);
  84                 errorCode = 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                 errorCode = calendar_record_set_caltime(todoHandle, _calendar_todo.start_time, convertedStartTime);
  97                 errorCode = calendar_record_set_caltime(todoHandle, _calendar_todo.due_time, convertedDueTime);
  98         }
  99
 100         // default value
 101         errorCode = calendar_record_set_int(todoHandle, _calendar_todo.todo_status, CALENDAR_TODO_STATUS_NONE);
 102         errorCode = calendar_record_set_int(todoHandle, _calendar_todo.priority, CALENDAR_TODO_PRIORITY_NORMAL);
 103         errorCode = 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         int errorCode = CALENDAR_ERROR_NONE;
 163         char* pSubject = null;
 164
 165         errorCode = calendar_record_get_str_p(__todoRecord.GetHandle(), _calendar_todo.summary, &pSubject);
 166
 167         return String(pSubject);
 168 }
 169
 170 String
 171 _CalTodoImpl::GetDescription(void) const
 172 {
 173         int errorCode = CALENDAR_ERROR_NONE;
 174         char* pDescription = null;
 175
 176         errorCode = calendar_record_get_str_p(__todoRecord.GetHandle(), _calendar_todo.description, &pDescription);
 177
 178         return String(pDescription);
 179 }
 180
 181 DateTime
 182 _CalTodoImpl::GetStartDate(void) const
 183 {
 184         ClearLastResult();
 185
 186         int errorCode = CALENDAR_ERROR_NONE;
 187         calendar_time_s tmpCalendarTime;
 188
 189         errorCode = calendar_record_get_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, &tmpCalendarTime);
 190
 191         if (tmpCalendarTime.time.utime == _CALENDAR_TODO_NO_START_DATE)
 192         {
 193                 SetLastResult(E_DATA_NOT_FOUND);
 194                 return DateTime::GetMinValue();
 195         }
 196
 197         DateTime tmpDateTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(tmpCalendarTime.time.utime);
 198
 199         return tmpDateTime;
 200 }
 201
 202 DateTime
 203 _CalTodoImpl::GetDueDate(void) const
 204 {
 205         ClearLastResult();
 206
 207         int errorCode = CALENDAR_ERROR_NONE;
 208         calendar_time_s tmpCalendarTime;
 209
 210         errorCode = calendar_record_get_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, &tmpCalendarTime);
 211
 212         if (tmpCalendarTime.time.utime == _CALENDAR_TODO_NO_DUE_DATE)
 213         {
 214                 SetLastResult(E_DATA_NOT_FOUND);
 215                 return DateTime::GetMinValue();
 216         }
 217
 218         DateTime tmpDateTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(tmpCalendarTime.time.utime);
 219
 220         return tmpDateTime;
 221 }
 222
 223 TodoPriority
 224 _CalTodoImpl::GetPriority(void) const
 225 {
 226         int errorCode = CALENDAR_ERROR_NONE;
 227         int srcPriority = CALENDAR_EVENT_PRIORITY_LOW;
 228
 229         TodoPriority priority = TODO_PRIORITY_NORMAL;
 230
 231         errorCode = calendar_record_get_int(__todoRecord.GetHandle(), _calendar_todo.priority, &srcPriority);
 232
 233         switch (srcPriority)
 234         {
 235         case CALENDAR_TODO_PRIORITY_LOW:
 236                 priority = TODO_PRIORITY_LOW;
 237                 break;
 238         case CALENDAR_TODO_PRIORITY_NONE:
 239                 // fall through
 240         case CALENDAR_TODO_PRIORITY_NORMAL:
 241                 priority = TODO_PRIORITY_NORMAL;
 242                 break;
 243         case CALENDAR_TODO_PRIORITY_HIGH:
 244                 priority = TODO_PRIORITY_HIGH;
 245                 break;
 246         default:
 247                 SysLog(NID_SCL, "The priority value is invalid. priority = %d", srcPriority);
 248                 priority = TODO_PRIORITY_NORMAL;
 249                 break;
 250         }
 251
 252         return priority;
 253 }
 254
 255 TodoStatus
 256 _CalTodoImpl::GetStatus(void) const
 257 {
 258         int errorCode = CALENDAR_ERROR_NONE;
 259         int srcStatus = CALENDAR_EVENT_STATUS_NONE;
 260
 261         TodoStatus status = TODO_STATUS_NONE;
 262
 263         errorCode = calendar_record_get_int(__todoRecord.GetHandle(), _calendar_todo.todo_status, &srcStatus);
 264
 265         switch (srcStatus)
 266         {
 267         case CALENDAR_TODO_STATUS_NONE:
 268                 status = TODO_STATUS_NONE;
 269                 break;
 270         case CALENDAR_TODO_STATUS_NEEDS_ACTION:
 271                 status = TODO_STATUS_NEEDS_ACTION;
 272                 break;
 273         case CALENDAR_TODO_STATUS_COMPLETED:
 274                 status = TODO_STATUS_COMPLETED;
 275                 break;
 276         case CALENDAR_TODO_STATUS_IN_PROCESS:
 277                 status = TODO_STATUS_IN_PROCESS;
 278                 break;
 279         case CALENDAR_TODO_STATUS_CANCELED:
 280                 status = TODO_STATUS_CANCELLED;
 281                 break;
 282         default:
 283                 SysLog(NID_SCL, "The status value is invalid. status = %d", srcStatus);
 284                 status = TODO_STATUS_NONE;
 285                 break;
 286         }
 287
 288         return status;
 289 }
 290
 291 RecordSensitivity
 292 _CalTodoImpl::GetSensitivity(void) const
 293 {
 294         int errorCode = CALENDAR_ERROR_NONE;
 295         int srcSensitivity = CALENDAR_SENSITIVITY_PUBLIC;
 296         RecordSensitivity sensitivity = SENSITIVITY_PUBLIC;
 297
 298         errorCode = calendar_record_get_int(__todoRecord.GetHandle(), _calendar_todo.sensitivity, &srcSensitivity);
 299
 300         switch (srcSensitivity)
 301         {
 302         case CALENDAR_SENSITIVITY_PUBLIC:
 303                 sensitivity = SENSITIVITY_PUBLIC;
 304                 break;
 305         case CALENDAR_SENSITIVITY_PRIVATE:
 306                 sensitivity = SENSITIVITY_PRIVATE;
 307                 break;
 308         case CALENDAR_SENSITIVITY_CONFIDENTIAL:
 309                 sensitivity = SENSITIVITY_CONFIDENTIAL;
 310                 break;
 311         default:
 312                 SysLog(NID_SCL, "The sensitivity value is invalid. sensitivity = %d", srcSensitivity);
 313                 sensitivity = SENSITIVITY_PUBLIC;
 314                 break;
 315         }
 316
 317         return sensitivity;
 318 }
 319
 320 DateTime
 321 _CalTodoImpl::GetLastRevisedTime(void) const
 322 {
 323         int errorCode = CALENDAR_ERROR_NONE;
 324         long long lastModifiedTime = 0;
 325         DateTime tmpLastRevisedTime;
 326
 327         errorCode = calendar_record_get_lli(__todoRecord.GetHandle(), _calendar_todo.last_modified_time, &lastModifiedTime);
 328
 329         tmpLastRevisedTime = _CalendarbookUtil::ConvertEpochTimeToDateTime(lastModifiedTime);
 330
 331         return tmpLastRevisedTime;
 332 }
 333
 334 result
 335 _CalTodoImpl::SetSubject(const String& subject)
 336 {
 337         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
 338         {
 339                 SysTryReturnResult(NID_SCL, subject.GetLength() <= MAX_TODO_SUBJECT_LENGTH,
 340                                         E_INVALID_ARG, "Invalid argument is used. The length of the subject exceeds MAX_TODO_SUBJECT_LENGTH.");
 341         }
 342
 343         std::unique_ptr<char[]> pConvertedSubject(_StringConverter::CopyToCharArrayN(subject));
 344         SysTryReturnResult(NID_SCL, pConvertedSubject != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 345
 346         int errorCode = CALENDAR_ERROR_NONE;
 347         errorCode = calendar_record_set_str(__todoRecord.GetHandle(), _calendar_todo.summary, pConvertedSubject.get());
 348
 349         return E_SUCCESS;
 350 }
 351
 352 result
 353 _CalTodoImpl::SetDescription(const String& description)
 354 {
 355         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
 356         {
 357                 SysTryReturnResult(NID_SCL, description.GetLength() <= MAX_TODO_DESCRIPTION_LENGTH,
 358                                         E_INVALID_ARG, "Invalid argument is used. The length of the description exceeds MAX_TODO_SUBJECT_LENGTH.");
 359         }
 360
 361         std::unique_ptr<char[]> pConvertedDescription(_StringConverter::CopyToCharArrayN(description));
 362         SysTryReturnResult(NID_SCL, pConvertedDescription != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 363
 364         int errorCode = CALENDAR_ERROR_NONE;
 365         errorCode = calendar_record_set_str(__todoRecord.GetHandle(), _calendar_todo.description, pConvertedDescription.get());
 366
 367         return E_SUCCESS;
 368 }
 369
 370 result
 371 _CalTodoImpl::SetStartAndDueDate(const DateTime& startDate, const DateTime& dueDate)
 372 {
 373         SysTryReturnResult(NID_SCL, _CalendarbookUtil::CheckValidDateTime(startDate), E_INVALID_ARG, "Invalid argument is used. The start date is invalid.");
 374         SysTryReturnResult(NID_SCL, _CalendarbookUtil::CheckValidDateTime(dueDate), E_INVALID_ARG, "Invalid argument is used. The end date is invalid.");
 375         SysTryReturnResult(NID_SCL, startDate <= dueDate, E_INVALID_ARG, "Invalid argument is used. The end date is earlier than the start date.");
 376
 377         int errorCode = CALENDAR_ERROR_NONE;
 378         calendar_time_s convertedStartTime;
 379         calendar_time_s convertedDueTime;
 380
 381         convertedStartTime.type = CALENDAR_TIME_UTIME;
 382         convertedStartTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(startDate);
 383         convertedDueTime.type = CALENDAR_TIME_UTIME;
 384         convertedDueTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(dueDate);
 385
 386         errorCode = calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, convertedStartTime);
 387         errorCode = calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, convertedDueTime);
 388
 389         return E_SUCCESS;
 390 }
 391
 392 result
 393 _CalTodoImpl::SetStartDate(const DateTime& startDate)
 394 {
 395         int errorCode = CALENDAR_ERROR_NONE;
 396         calendar_time_s convertedStartTime;
 397         convertedStartTime.type = CALENDAR_TIME_UTIME;
 398
 399         if (startDate == DateTime::GetMinValue())
 400         {
 401                 convertedStartTime.time.utime = _CALENDAR_TODO_NO_START_DATE;
 402         }
 403         else if (startDate < _CalendarbookImpl::GetMinDateTime() || startDate > _CalendarbookImpl::GetMaxDateTime())
 404         {
 405                 SysLogException(NID_SCL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used.  The startDate is invalid.");
 406                 return E_INVALID_ARG;
 407         }
 408         else
 409         {
 410                 calendar_time_s convertedDueTime;
 411                 errorCode = calendar_record_get_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, &convertedDueTime);
 412
 413                 convertedStartTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(startDate);
 414
 415                 if (convertedStartTime.time.utime > convertedDueTime.time.utime)
 416                 {
 417                         convertedDueTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(DateTime::GetMinValue());
 418                         errorCode = calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, convertedDueTime);
 419                 }
 420         }
 421
 422         errorCode = calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, convertedStartTime);
 423
 424
 425         return E_SUCCESS;
 426 }
 427
 428 result
 429 _CalTodoImpl::SetDueDate(const DateTime& dueDate)
 430 {
 431         int errorCode = CALENDAR_ERROR_NONE;
 432         calendar_time_s convertedDueTime;
 433         convertedDueTime.type = CALENDAR_TIME_UTIME;
 434
 435         if (dueDate == DateTime::GetMinValue())
 436         {
 437                 convertedDueTime.time.utime = _CALENDAR_TODO_NO_DUE_DATE;
 438         }
 439         else if (dueDate < _CalendarbookImpl::GetMinDateTime() || dueDate > _CalendarbookImpl::GetMaxDateTime())
 440         {
 441                 SysLogException(NID_SCL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used.  The dueDate is invalid.");
 442                 return E_INVALID_ARG;
 443         }
 444         else
 445         {
 446                 calendar_time_s convertedStartTime;
 447                 errorCode = calendar_record_get_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, &convertedStartTime);
 448
 449                 convertedDueTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(dueDate);
 450
 451                 if (convertedStartTime.time.utime > convertedDueTime.time.utime)
 452                 {
 453                         convertedStartTime.time.utime = _CalendarbookUtil::ConvertDateTimeToEpochTime(DateTime::GetMinValue());
 454                         errorCode = calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.start_time, convertedStartTime);
 455                 }
 456         }
 457
 458         errorCode = calendar_record_set_caltime(__todoRecord.GetHandle(), _calendar_todo.due_time, convertedDueTime);
 459
 460         return E_SUCCESS;
 461 }
 462
 463 void
 464 _CalTodoImpl::SetPriority(TodoPriority priority)
 465 {
 466         int errorCode = CALENDAR_ERROR_NONE;
 467         errorCode = calendar_record_set_int(__todoRecord.GetHandle(), _calendar_todo.priority, _CalendarbookUtil::ConvertTodoPriorityToCSTodoPriority(priority));
 468 }
 469
 470 void
 471 _CalTodoImpl::SetStatus(TodoStatus status)
 472 {
 473         int errorCode = CALENDAR_ERROR_NONE;
 474         errorCode = calendar_record_set_int(__todoRecord.GetHandle(), _calendar_todo.todo_status, _CalendarbookUtil::ConvertTodoStatusToCSTodoStatus(status));
 475 }
 476
 477 void
 478 _CalTodoImpl::SetSensitivity(RecordSensitivity sensitivity)
 479 {
 480         int errorCode = CALENDAR_ERROR_NONE;
 481         errorCode = calendar_record_set_int(__todoRecord.GetHandle(), _calendar_todo.sensitivity, _CalendarbookUtil::ConvertSensitivityToCSSensitivity(sensitivity));
 482 }
 483
 484 void
 485 _CalTodoImpl::SetLocation(const String& location)
 486 {
 487         std::unique_ptr<char[]> pConvertedLocation(_StringConverter::CopyToCharArrayN(location));
 488         SysTryReturnVoidResult(NID_SCL, pConvertedLocation != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 489
 490         int errorCode = CALENDAR_ERROR_NONE;
 491         errorCode = calendar_record_set_str(__todoRecord.GetHandle(), _calendar_todo.location, pConvertedLocation.get());
 492 }
 493
 494 String
 495 _CalTodoImpl::GetLocation(void) const
 496 {
 497         int errorCode = CALENDAR_ERROR_NONE;
 498         char* pLocation = null;
 499
 500         errorCode = calendar_record_get_str_p(__todoRecord.GetHandle(), _calendar_todo.location, &pLocation);
 501
 502         return String(pLocation);
 503 }
 504
 505 result
 506 _CalTodoImpl::SetCoordinates(double latitude, double longitude)
 507 {
 508         SysTryReturnResult(NID_SCL, latitude >= _MIN_LATITUDE && latitude <= _MAX_LATITUDE, E_INVALID_ARG, "Invalid argument is used. The latitude is out of range.");
 509         SysTryReturnResult(NID_SCL, longitude >= _MIN_LONGITUDE && longitude <= _MAX_LONGITUDE, E_INVALID_ARG, "Invalid argument is used. The longitude is out of range.");
 510
 511         int errorCode = CALENDAR_ERROR_NONE;
 512
 513         errorCode = calendar_record_set_double(__todoRecord.GetHandle(), _calendar_todo.latitude, latitude);
 514         errorCode = calendar_record_set_double(__todoRecord.GetHandle(), _calendar_todo.longitude, longitude);
 515
 516         return E_SUCCESS;
 517 }
 518
 519 void
 520 _CalTodoImpl::GetCoordinates(double& latitude, double& longitude) const
 521 {
 522         int errorCode = CALENDAR_ERROR_NONE;
 523
 524         errorCode = calendar_record_get_double(__todoRecord.GetHandle(), _calendar_todo.latitude, &latitude);
 525         errorCode = calendar_record_get_double(__todoRecord.GetHandle(), _calendar_todo.longitude, &longitude);
 526 }
 527
 528 result
 529 _CalTodoImpl::AddReminder(const Reminder& reminder)
 530 {
 531         int errorCode = CALENDAR_ERROR_NONE;
 532         calendar_record_h tmpAlarmHandle = null;
 533
 534         std::unique_ptr<char[]> pTmpAlarmTone(_StringConverter::CopyToCharArrayN(reminder.GetSoundFile()));
 535         SysTryReturnResult(NID_SCL, pTmpAlarmTone != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 536
 537         errorCode = calendar_record_create(_calendar_alarm._uri, &tmpAlarmHandle);
 538         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "Memory allocation failed.");
 539
 540         int convertedTimeUnit = 0;
 541
 542         ReminderTimeUnit timeUnit = reminder.GetTimeUnit();
 543         switch (timeUnit)
 544         {
 545         case REMINDER_TIME_UNIT_MINUTE:
 546                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_MINUTE;
 547                 break;
 548         case REMINDER_TIME_UNIT_HOUR:
 549                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_HOUR;
 550                 break;
 551         case REMINDER_TIME_UNIT_DAY:
 552                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_DAY;
 553                 break;
 554         case REMINDER_TIME_UNIT_WEEK:
 555                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_WEEK;
 556                 break;
 557         case REMINDER_TIME_UNIT_NONE:
 558                 convertedTimeUnit = CALENDAR_ALARM_TIME_UNIT_SPECIFIC;
 559                 break;
 560         default:
 561                 break;
 562         }
 563
 564         errorCode = calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick_unit, convertedTimeUnit);
 565         errorCode = calendar_record_set_int(tmpAlarmHandle, _calendar_alarm.tick, reminder.GetTimeOffset());
 566         errorCode = calendar_record_set_str(tmpAlarmHandle, _calendar_alarm.tone, pTmpAlarmTone.get());
 567
 568         if (convertedTimeUnit == CALENDAR_ALARM_TIME_UNIT_SPECIFIC)
 569         {
 570                 errorCode = calendar_record_set_lli(tmpAlarmHandle, _calendar_alarm.time, _CalendarbookUtil::ConvertDateTimeToEpochTime(reminder.GetAbsoluteTime()));
 571         }
 572
 573         errorCode = calendar_record_add_child_record(__todoRecord.GetHandle(), _calendar_todo.calendar_alarm, tmpAlarmHandle);
 574
 575         __reminderList.RemoveAll(true);
 576         __reminderListUpdated = false;
 577
 578         return E_SUCCESS;
 579 }
 580
 581 result
 582 _CalTodoImpl::RemoveReminderAt(int index)
 583 {
 584         int errorCode = CALENDAR_ERROR_NONE;
 585         calendar_record_h tmpAlarmHandle = null;
 586
 587         errorCode = calendar_record_get_child_record_at_p(__todoRecord.GetHandle(), _calendar_todo.calendar_alarm, index, &tmpAlarmHandle);
 588         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.");
 589
 590         errorCode = calendar_record_remove_child_record(__todoRecord.GetHandle(), _calendar_todo.calendar_alarm, tmpAlarmHandle);
 591
 592         __reminderList.RemoveAll(true);
 593         __reminderListUpdated = false;
 594
 595         return E_SUCCESS;
 596 }
 597
 598 const IList&
 599 _CalTodoImpl::GetAllReminders(void) const
 600 {
 601         ClearLastResult();
 602
 603         if (__reminderListUpdated == false)
 604         {
 605                 result r = _CalendarbookUtil::ConvertTodoAlarmsToReminderList(__todoRecord.GetHandle(), __reminderList);
 606                 SysTryReturn(NID_SCL, r == E_SUCCESS, __reminderList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 607
 608                 __reminderListUpdated = true;
 609         }
 610
 611         return __reminderList;
 612 }
 613
 614 RecordId
 615 _CalTodoImpl::GetCalendarId(void) const
 616 {
 617         int errorCode = CALENDAR_ERROR_NONE;
 618         int srcCalendarbookId = 0;
 619
 620         errorCode = calendar_record_get_int(__todoRecord.GetHandle(), _calendar_todo.calendar_book_id, &srcCalendarbookId);
 621
 622         return srcCalendarbookId;
 623 }
 624
 625 void
 626 _CalTodoImpl::SetRecordHandle(calendar_record_h todoHandle)
 627 {
 628         __todoRecord.ResetHandle(todoHandle);
 629 }
 630
 631 calendar_record_h
 632 _CalTodoImpl::GetRecordHandle(void) const
 633 {
 634         return __todoRecord.GetHandle();
 635 }
 636
 637 CalTodo*
 638 _CalTodoImpl::CreateDefaultInstanceN(void)
 639 {
 640         return new (std::nothrow) CalTodo();
 641 }
 642
 643 _CalTodoImpl*
 644 _CalTodoImpl::GetInstance(CalTodo& todo)
 645 {
 646         return todo.__pCalTodoImpl;
 647 }
 648
 649 const _CalTodoImpl*
 650 _CalTodoImpl::GetInstance(const CalTodo& todo)
 651 {
 652         return todo.__pCalTodoImpl;
 653 }
 654
 655 }}      //OSP::Social