src/ClkAlarm.cpp

   1 //
   2 //  Tizen Native SDK
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.1 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        ClkAlarm.cpp
  20  * @brief       Used to define %Alarm class.
  21  */
  22 #include <FApp.h>
  23 #include <FBase.h>
  24 #include <FLocales.h>
  25
  26 #include "ClkAlarm.h"
  27 #include "ClkAlarmPresentationModel.h"
  28
  29 using namespace Tizen::Base;
  30 using namespace Tizen::Locales;
  31
  32 AlarmData::AlarmData(void)
  33         : __alarmId(0)
  34         , __alarmName("")
  35         , __isOn(0)
  36         , __repeatEveryFriday(false)
  37         , __repeatEveryMonday(false)
  38         , __repeatEverySaturday(false)
  39         , __repeatEverySunday(false)
  40         , __repeatEveryThursday(false)
  41         , __repeatEveryTuesday(false)
  42         , __repeatEveryWednesday(false)
  43         , __repeatFlags("")
  44         , __ringType(ALARM_TYPE_MELODY)
  45         , __ringVolume(0)
  46         , __snoozeDuration(5)
  47         , __snoozeOn(true)
  48         , __snoozeRepeat(3)
  49         , __snoozeRepeatCount(0)
  50
  51 {
  52         __time.SetValue(00, 00, 00);
  53         __lastRingingTime.SetValue(00, 00, 00);
  54         __ringTone = Tizen::App::App::GetInstance()->GetAppRootPath() + L"data/Walk in the forest.mp3";
  55
  56 }
  57
  58 AlarmData::AlarmData(const AlarmData& alarm)
  59 {
  60         __alarmId = alarm.__alarmId;
  61         __isOn = alarm.__isOn;
  62         __alarmName = alarm.__alarmName;
  63         __repeatFlags = alarm.__repeatFlags;
  64         __snoozeOn = alarm.__snoozeOn;
  65         __snoozeDuration = alarm.__snoozeDuration;
  66         __snoozeRepeat = alarm.__snoozeRepeat;
  67         __ringVolume = alarm.__ringVolume;
  68         __ringType = alarm.__ringType;
  69         __ringTone = alarm.__ringTone;
  70         __time = alarm.__time;
  71         __lastRingingTime = alarm.__lastRingingTime;
  72         __repeatEveryMonday = alarm.__repeatEveryMonday;
  73         __repeatEveryTuesday= alarm.__repeatEveryTuesday;
  74         __repeatEveryWednesday = alarm.__repeatEveryWednesday;
  75         __repeatEveryThursday = alarm.__repeatEveryThursday;
  76         __repeatEveryFriday = alarm.__repeatEveryFriday;
  77         __repeatEverySaturday = alarm.__repeatEverySaturday;
  78         __repeatEverySunday = alarm.__repeatEverySunday;
  79         __snoozeRepeatCount = alarm.__snoozeRepeatCount;
  80 }
  81
  82 AlarmData::~AlarmData(void)
  83 {
  84
  85 }
  86
  87 AlarmData&
  88 AlarmData::operator =(const AlarmData& rhs)
  89 {
  90         if (this != &rhs)
  91         {
  92                 __alarmId = rhs.__alarmId;
  93                 __isOn = rhs.__isOn;
  94                 __alarmName = rhs.__alarmName;
  95                 __repeatFlags = rhs.__repeatFlags;
  96                 __snoozeOn = rhs.__snoozeOn;
  97                 __snoozeDuration = rhs.__snoozeDuration;
  98                 __snoozeRepeat = rhs.__snoozeRepeat;
  99                 __ringVolume = rhs.__ringVolume;
 100                 __ringType = rhs.__ringType;
 101                 __ringTone = rhs.__ringTone;
 102                 __time = rhs.__time;
 103                 __lastRingingTime = rhs.__lastRingingTime;
 104                 __repeatEveryMonday = rhs.__repeatEveryMonday;
 105                 __repeatEveryTuesday= rhs.__repeatEveryTuesday;
 106                 __repeatEveryWednesday = rhs.__repeatEveryWednesday;
 107                 __repeatEveryThursday = rhs.__repeatEveryThursday;
 108                 __repeatEveryFriday = rhs.__repeatEveryFriday;
 109                 __repeatEverySaturday = rhs.__repeatEverySaturday;
 110                 __repeatEverySunday = rhs.__repeatEverySunday;
 111                 __snoozeRepeatCount = rhs.__snoozeRepeatCount;
 112         }
 113
 114         return *this;
 115 }
 116
 117 int
 118 AlarmData::GetAlarmId(void) const
 119 {
 120         return __alarmId;
 121 }
 122
 123 int
 124 AlarmData::GetAlarmOnState(void) const
 125 {
 126         return __isOn;
 127 }
 128
 129 String
 130 AlarmData::GetAlarmName(void) const
 131 {
 132         return __alarmName;
 133 }
 134
 135 DateTime
 136 AlarmData::GetAlarmTime(void) const
 137 {
 138         return __time;
 139 }
 140
 141 DateTime
 142 AlarmData::GetLastRingingTime(void) const
 143 {
 144         return __lastRingingTime;
 145 }
 146
 147 DateTime
 148 AlarmData::GetAlarmCreatedtime(void) const
 149 {
 150         return __alarmCreatedTime;
 151 }
 152
 153 DateTime
 154 AlarmData::GetNextRingingTime()
 155 {
 156         result r = E_FAILURE;
 157         DateTime currentTime;
 158         DateTime nextRingingTime;
 159         int status = 0;
 160         int dayOfWeek = -1;
 161         int nextRepeatFlag = 0;
 162         int noOfDaysInWeek = 7;
 163         Calendar* pGregorianCalendar = null;
 164         DataServiceProvider* pDataServiceProvider = DataServiceProvider::GetInstance();
 165
 166         pDataServiceProvider->GetCurrentDateTime(currentTime);
 167         currentTime.AddSeconds(-2);
 168         pGregorianCalendar = Calendar::CreateInstanceN(CALENDAR_GREGORIAN);
 169         pGregorianCalendar->SetTimeField(TIME_FIELD_YEAR, currentTime.GetYear());
 170         pGregorianCalendar->SetTimeField(TIME_FIELD_MONTH, currentTime.GetMonth());
 171         pGregorianCalendar->SetTimeField(TIME_FIELD_DAY_OF_MONTH, currentTime.GetDay());
 172         dayOfWeek = pGregorianCalendar->GetTimeField(TIME_FIELD_DAY_OF_WEEK);
 173         __repeatFlags.IndexOf(L"1",0,nextRepeatFlag);
 174         AppLog("dayOfWeek = %d nextRepeatFlag = %d", dayOfWeek, nextRepeatFlag);
 175         if (__isOn == 1)
 176         {
 177                 nextRingingTime.SetValue(currentTime.GetYear(), currentTime.GetMonth(), currentTime.GetDay(), __time.GetHour(), __time.GetMinute(), __time.GetSecond());
 178
 179                 if (__snoozeOn == true && __snoozeRepeatCount >= 0)
 180                 {
 181                         wchar_t ch;
 182
 183                         nextRingingTime.AddMinutes(__snoozeDuration * (__snoozeRepeat - __snoozeRepeatCount));
 184                         status = nextRingingTime.CompareTo(currentTime);
 185                         __repeatFlags.GetCharAt(dayOfWeek - 1, ch);
 186
 187                         if (status >= 0 && (ch == '1' || nextRepeatFlag == -1))
 188                         {
 189                                 return nextRingingTime;
 190                         }
 191                 }
 192
 193                 __snoozeRepeatCount = __snoozeRepeat;
 194                 nextRingingTime.SetValue(currentTime.GetYear(),currentTime.GetMonth(),currentTime.GetDay(),__time.GetHour(),__time.GetMinute(),__time.GetSecond());
 195
 196                 __repeatFlags.IndexOf(L"1",dayOfWeek - 1,nextRepeatFlag);
 197                 status = nextRingingTime.CompareTo(currentTime);
 198
 199                 if (nextRepeatFlag == dayOfWeek - 1)
 200                 {
 201                         if (status >= 0)
 202                         {
 203                                 return nextRingingTime;
 204                         }
 205                 }
 206
 207                 r = __repeatFlags.IndexOf(L"1",dayOfWeek,nextRepeatFlag);
 208
 209                 if (nextRepeatFlag == -1 || r != E_SUCCESS)
 210                 {
 211                         r = __repeatFlags.IndexOf(L"1",0,nextRepeatFlag);
 212
 213                         if (nextRepeatFlag != -1 && r == E_SUCCESS)
 214                         {
 215                                 nextRingingTime.AddDays(noOfDaysInWeek + (nextRepeatFlag - dayOfWeek + 1));
 216                         }
 217                         else
 218                         {
 219                                 nextRingingTime.SetValue(currentTime.GetYear(),currentTime.GetMonth(),currentTime.GetDay(),__time.GetHour(),__time.GetMinute(),__time.GetSecond());
 220                                 status = nextRingingTime.CompareTo(currentTime);
 221
 222                                 if (status >= 0)
 223                                 {
 224                                         return nextRingingTime;
 225                                 }
 226                                 else if (__repeatFlags.Contains(L"1") == false)
 227                                 {
 228                                         nextRingingTime.AddDays(1);
 229                                 }
 230
 231                         }
 232                 }
 233                 else
 234                 {
 235                         nextRingingTime.AddDays(nextRepeatFlag - dayOfWeek + 1);
 236                 }
 237
 238         }
 239         status = nextRingingTime.CompareTo(currentTime);
 240
 241         if (status < 0)
 242         {
 243                 nextRingingTime.SetValue(9999,1,1);
 244         }
 245
 246         return nextRingingTime;
 247 }
 248
 249 String
 250 AlarmData::GetRepeatFlags(void)
 251 {
 252         __repeatFlags = L"0000000";
 253
 254         if (__repeatEverySunday == true)
 255         {
 256                 __repeatFlags[0] = '1';
 257         }
 258         else
 259         {
 260                 __repeatFlags[0] = '0';
 261         }
 262
 263         if (__repeatEveryMonday == true)
 264         {
 265                 __repeatFlags[1] = '1';
 266         }
 267         else
 268         {
 269                 __repeatFlags[1] = '0';
 270         }
 271
 272         if (__repeatEveryTuesday == true)
 273         {
 274                 __repeatFlags[2] = '1';
 275         }
 276         else
 277         {
 278                 __repeatFlags[2] = '0';
 279         }
 280
 281         if (__repeatEveryWednesday == true)
 282         {
 283                 __repeatFlags[3] = '1';
 284         }
 285         else
 286         {
 287                 __repeatFlags[3] = '0';
 288         }
 289
 290         if (__repeatEveryThursday == true)
 291         {
 292                 __repeatFlags[4] = '1';
 293         }
 294         else
 295         {
 296                 __repeatFlags[4] = '0';
 297         }
 298
 299         if (__repeatEveryFriday == true)
 300         {
 301                 __repeatFlags[5] = '1';
 302         }
 303         else
 304         {
 305                 __repeatFlags[5] = '0';
 306         }
 307
 308         if (__repeatEverySaturday == true)
 309         {
 310                 __repeatFlags[6] = '1';
 311         }
 312         else
 313         {
 314                 __repeatFlags[6] = '0';
 315         }
 316         return __repeatFlags;
 317
 318 }
 319
 320 bool
 321 AlarmData::GetRepeatEveryMondayFlag(void) const
 322 {
 323         return __repeatEveryMonday;
 324 }
 325
 326 bool
 327 AlarmData::GetRepeatEveryTuesdayFlag(void) const
 328 {
 329         return __repeatEveryTuesday;
 330 }
 331
 332 bool
 333 AlarmData::GetRepeatEveryWednesdayFlag(void) const
 334 {
 335         return __repeatEveryWednesday;
 336 }
 337
 338 bool
 339 AlarmData::GetRepeatEveryThursdayFlag(void) const
 340 {
 341         return __repeatEveryThursday;
 342 }
 343
 344 bool
 345 AlarmData::GetRepeatEveryFridayFlag(void) const
 346 {
 347         return __repeatEveryFriday;
 348 }
 349
 350 bool
 351 AlarmData::GetRepeatEverySaturdayFlag(void) const
 352 {
 353         return __repeatEverySaturday;
 354 }
 355
 356 bool
 357 AlarmData::GetRepeatEverySundayFlag(void) const
 358 {
 359         return __repeatEverySunday;
 360 }
 361
 362 bool
 363 AlarmData::GetSnoozeOn(void) const
 364 {
 365         return __snoozeOn;
 366 }
 367
 368 int
 369 AlarmData::GetSnoozeDuration(void) const
 370 {
 371         return __snoozeDuration;
 372 }
 373
 374 int
 375 AlarmData::GetSnoozeRepeat(void) const
 376 {
 377         return __snoozeRepeat;
 378 }
 379
 380 int
 381 AlarmData::GetSnoozeRepeatCount(void) const
 382 {
 383         return __snoozeRepeatCount;
 384 }
 385
 386 int
 387 AlarmData::GetRingVolume(void) const
 388 {
 389         return __ringVolume;
 390 }
 391
 392 type
 393 AlarmData::GetRingType(void) const
 394 {
 395         return __ringType;
 396 }
 397
 398 String
 399 AlarmData::GetRingTone(void) const
 400 {
 401         return __ringTone;
 402 }
 403
 404 void
 405 AlarmData::SetAlarmId(const int& alarmId)
 406 {
 407         __alarmId = alarmId;
 408 }
 409
 410 void
 411 AlarmData::SetAlarmOnState(const int& alarmOnState)
 412 {
 413
 414         __isOn = alarmOnState;
 415 }
 416
 417 void
 418 AlarmData::SetAlarmName(const String& alarmName)
 419 {
 420         __alarmName = alarmName;
 421 }
 422
 423 void
 424 AlarmData::SetSnoozeOn(const bool snooze)
 425 {
 426         __snoozeOn = snooze;
 427 }
 428
 429 void
 430 AlarmData::SetSnoozeDuration(const int& duration)
 431 {
 432         __snoozeDuration = duration;
 433 }
 434
 435 void
 436 AlarmData::SetAlarmTime(const DateTime& time)
 437 {
 438         __time = time;
 439 }
 440
 441 void
 442 AlarmData::SetSnoozeRepeat(const int& repeat)
 443 {
 444         __snoozeRepeat = repeat;
 445         __snoozeRepeatCount = repeat;
 446 }
 447
 448 void
 449 AlarmData::SetRingVolume(const int& volume)
 450 {
 451         __ringVolume = volume;
 452 }
 453
 454 void
 455 AlarmData::SetRingType(const type& type)
 456 {
 457         __ringType = type;
 458 }
 459
 460 void
 461 AlarmData::SetRingTone(const String& ringTone)
 462 {
 463         __ringTone = ringTone;
 464 }
 465
 466 void
 467 AlarmData::SetRepeatedFlags(const String& repeat)
 468 {
 469         __repeatFlags = repeat;
 470
 471         for (int i =0; i < __repeatFlags.GetLength(); i++)
 472         {
 473                 bool flag = false;
 474                 String strFlag;
 475                 __repeatFlags.SubString(i, 1, strFlag);
 476
 477                 if (strFlag == "1")
 478                 {
 479                         flag = true;
 480                 }
 481                 else
 482                 {
 483                         flag = false;
 484                 }
 485
 486                 AppLogDebug("the flag is %d and the strflag is %ls", flag, strFlag.GetPointer());
 487
 488                 switch (i)
 489                 {
 490                 case 0:
 491                         SetRepeatedEverySunday(flag);
 492                         break;
 493                 case 1:
 494                         SetRepeatedEveryMonday(flag);
 495                         break;
 496                 case 2:
 497                         SetRepeatedEveryTuesday(flag);
 498                         break;
 499                 case 3:
 500                         SetRepeatedEveryWednesday(flag);
 501                         break;
 502                 case 4:
 503                         SetRepeatedEveryThursday(flag);
 504                         break;
 505                 case 5:
 506                         SetRepeatedEveryFriday(flag);
 507                         break;
 508                 case 6:
 509                         SetRepeatedEverySaturday(flag);
 510                         break;
 511                 default:
 512                 break;
 513                 }
 514         }
 515 }
 516 void
 517 AlarmData::SetRepeatedEveryMonday(const bool repeat)
 518 {
 519         __repeatEveryMonday = repeat;
 520 }
 521
 522 void
 523 AlarmData::SetRepeatedEveryTuesday(const bool repeat)
 524 {
 525         __repeatEveryTuesday = repeat;
 526 }
 527
 528 void
 529 AlarmData::SetRepeatedEveryWednesday(const bool repeat)
 530 {
 531         __repeatEveryWednesday = repeat;
 532 }
 533
 534 void
 535 AlarmData::SetRepeatedEveryThursday(const bool repeat)
 536 {
 537         __repeatEveryThursday = repeat;
 538 }
 539
 540 void
 541 AlarmData::SetRepeatedEveryFriday(const bool repeat)
 542 {
 543         __repeatEveryFriday = repeat;
 544 }
 545
 546 void
 547 AlarmData::SetRepeatedEverySaturday(const bool repeat)
 548 {
 549         __repeatEverySaturday = repeat;
 550 }
 551
 552 void
 553 AlarmData::SetRepeatedEverySunday(const bool repeat)
 554 {
 555         __repeatEverySunday = repeat;
 556 }
 557
 558 void
 559 AlarmData::SetLastRingingTime(const DateTime& lastRingingTime)
 560 {
 561         __lastRingingTime = lastRingingTime;
 562 }
 563
 564 void
 565 AlarmData::SetSnoozeRepeatCount(const int& count)
 566 {
 567         __snoozeRepeatCount = count;
 568 }
 569
 570 void
 571 AlarmData::SetAlarmCreatedTime(const DateTime& alarmCreatedTime)
 572 {
 573         __alarmCreatedTime = alarmCreatedTime;
 574 }
 575