src/alarm.c

   1 /*
   2  * Copyright (c) 2011 - 2016 Samsung Electronics Co., Ltd All Rights Reserved
   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
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22 #include <time.h>
  23 #include <sys/time.h>
  24
  25 #include <bundle.h>
  26 #include <alarm.h>
  27 #include <dlog.h>
  28
  29 #include <app_alarm.h>
  30 #include <app_control_internal.h>
  31
  32 #include <notification.h>
  33
  34 #ifdef LOG_TAG
  35 #undef LOG_TAG
  36 #endif
  37
  38 #define LOG_TAG "CAPI_APPFW_APPLICATION_ALARM"
  39
  40 typedef struct {
  41         alarm_registered_alarm_cb cb;
  42         void *user_data;
  43         bool *foreach_break;
  44 } alarm_foreach_item_cb_context;
  45
  46 static int alarm_registered_alarm_cb_broker(int alarm_id, void *user_data)
  47 {
  48         alarm_foreach_item_cb_context *foreach_cb_context = NULL;
  49
  50         if (user_data == NULL)
  51                 return 0;
  52
  53         foreach_cb_context = (alarm_foreach_item_cb_context *)user_data;
  54
  55         if (foreach_cb_context != NULL && *(foreach_cb_context->foreach_break) == false) {
  56                 if (foreach_cb_context->cb(alarm_id, foreach_cb_context->user_data) == false)
  57                         *(foreach_cb_context->foreach_break) = true;
  58         }
  59
  60         return 0;
  61 }
  62
  63 /* LCOV_EXCL_START */
  64 static int convert_error_code_to_alarm(const char *function, alarm_error_t alarm_error)
  65 {
  66         switch (alarm_error) {
  67         case ERR_ALARM_INVALID_PARAM:
  68         case ERR_ALARM_INVALID_REPEAT:
  69                 LOGE("[%s] INVALID_PARAMETER(0x%08x)", function, ALARM_ERROR_INVALID_PARAMETER);
  70                 return ALARM_ERROR_INVALID_PARAMETER;
  71                 break;
  72         case ERR_ALARM_INVALID_ID:
  73                 LOGE("[%s] INVALID_PARAMETER(0x%08x)", function, ALARM_ERROR_INVALID_PARAMETER);
  74                 return ALARM_ERROR_INVALID_PARAMETER;
  75                 break;
  76         case ERR_ALARM_INVALID_TIME:
  77                 LOGE("[%s] INVALID_TIME(0x%08x)", function, ALARM_ERROR_INVALID_TIME);
  78                 return ALARM_ERROR_INVALID_TIME;
  79                 break;
  80         case ERR_ALARM_INVALID_DATE:
  81                 LOGE("[%s] INVALID_DATE(0x%08x)", function, ALARM_ERROR_INVALID_DATE);
  82                 return ALARM_ERROR_INVALID_DATE;
  83                 break;
  84         case ERR_ALARM_NO_SERVICE_NAME:
  85                 LOGE("[%s] INVALID_PARAMETER(0x%08x)", function, ALARM_ERROR_INVALID_PARAMETER);
  86                 return ALARM_ERROR_INVALID_PARAMETER;
  87                 break;
  88         case ERR_ALARM_SYSTEM_FAIL:
  89                 LOGE("[%s] CONNECTION_FAIL(0x%08x)", function, ALARM_ERROR_CONNECTION_FAIL);
  90                 return ALARM_ERROR_CONNECTION_FAIL;
  91                 break;
  92         case ERR_ALARM_NO_PERMISSION:
  93                 LOGE("[%s] PERMISSION_DENIED(0x%08x)", function, ALARM_ERROR_PERMISSION_DENIED);
  94                 return ALARM_ERROR_PERMISSION_DENIED;
  95                 break;
  96         case ERR_ALARM_NOT_PERMITTED_APP:
  97                 LOGE("[%s] NOT_PERMITTED_APP(0x%08x)", function, ALARM_ERROR_NOT_PERMITTED_APP);
  98                 return ALARM_ERROR_NOT_PERMITTED_APP;
  99                 break;
 100         case ALARMMGR_RESULT_SUCCESS:
 101                 return ALARM_ERROR_NONE;
 102                 break;
 103         default:
 104                 return ALARM_ERROR_INVALID_PARAMETER;
 105         }
 106 }
 107 /* LCOV_EXCL_STOP */
 108
 109 int alarm_get_scheduled_date(int alarm_id, struct tm *date)
 110 {
 111         alarm_error_t result;
 112         time_t due_time = 0;
 113
 114         if (date == NULL) {
 115                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 116                 return ALARM_ERROR_INVALID_PARAMETER;
 117         }
 118
 119         result = alarmmgr_get_next_duetime(alarm_id, &due_time);
 120         if (result != ALARMMGR_RESULT_SUCCESS)
 121                 return convert_error_code_to_alarm(__FUNCTION__, result);
 122
 123         localtime_r(&due_time, date);
 124
 125         return ALARM_ERROR_NONE;
 126 }
 127
 128 int alarm_get_scheduled_period(int alarm_id, int *period)
 129 {
 130         alarm_error_t result;
 131         alarm_entry_t *entry = NULL;
 132         alarm_repeat_mode_t mode;
 133         int value;
 134
 135         if (period == NULL) {
 136                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 137                 return ALARM_ERROR_INVALID_PARAMETER;
 138         }
 139
 140         entry = alarmmgr_create_alarm();
 141
 142         result = alarmmgr_get_info(alarm_id, entry);
 143         if (result != ALARMMGR_RESULT_SUCCESS) {
 144                 if (entry != NULL)
 145                         alarmmgr_free_alarm(entry);
 146
 147                 return convert_error_code_to_alarm(__FUNCTION__, result);
 148         }
 149
 150         result = alarmmgr_get_repeat_mode(entry, &mode, &value);
 151         if (result != ALARMMGR_RESULT_SUCCESS) {
 152                 if (entry != NULL)
 153                         alarmmgr_free_alarm(entry);
 154
 155                 return convert_error_code_to_alarm(__FUNCTION__, result);
 156         }
 157
 158         alarmmgr_free_alarm(entry);
 159
 160         (*period) = value;
 161
 162         return ALARM_ERROR_NONE;
 163 }
 164
 165 int alarm_schedule_after_delay(app_control_h app_control, int delay, int period, int *alarm_id)
 166 {
 167         bundle *bundle_data;
 168         int result = 0;
 169
 170         if (app_control == NULL) {
 171                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 172                 return ALARM_ERROR_INVALID_PARAMETER;
 173         }
 174
 175         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE) {
 176                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 177                 return ALARM_ERROR_INVALID_PARAMETER;
 178         }
 179
 180         result = alarmmgr_add_alarm_appsvc(ALARM_TYPE_DEFAULT | ALARM_TYPE_INEXACT, delay, period, bundle_data, alarm_id);
 181
 182         return  convert_error_code_to_alarm(__FUNCTION__, result);
 183 }
 184
 185 int alarm_schedule_noti_after_delay(notification_h noti, int delay, int period, int *alarm_id)
 186 {
 187         int result;
 188
 189         if (noti == NULL) {
 190                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 191                 return ALARM_ERROR_INVALID_PARAMETER;
 192         }
 193
 194         result = alarmmgr_add_alarm_noti(ALARM_TYPE_DEFAULT | ALARM_TYPE_INEXACT, delay, period, noti, alarm_id);
 195
 196         return  convert_error_code_to_alarm(__FUNCTION__, result);
 197 }
 198
 199 int alarm_schedule_at_date(app_control_h app_control, struct tm *date, int period_in_second, int *alarm_id)
 200 {
 201         dlog_print(DLOG_WARN, LOG_TAG, "DEPRECATION WARNING: alarm_schedule_at_date() is deprecated and will be removed from next release. Use alarm_schedule_once_at_date() instead.");
 202         alarm_date_t internal_time;
 203         alarm_entry_t *alarm_info;
 204         bundle *bundle_data;
 205         int result;
 206
 207         if (app_control == NULL || date == NULL) {
 208                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 209                 return ALARM_ERROR_INVALID_PARAMETER;
 210         }
 211
 212         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE) {
 213                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 214                 return ALARM_ERROR_INVALID_PARAMETER;
 215         }
 216
 217         alarm_info = alarmmgr_create_alarm();
 218
 219         internal_time.year = date->tm_year + 1900;
 220         internal_time.month = date->tm_mon + 1;
 221         internal_time.day = date->tm_mday;
 222
 223         internal_time.hour = date->tm_hour;
 224         internal_time.min = date->tm_min;
 225         internal_time.sec = date->tm_sec;
 226
 227         result = alarmmgr_set_time(alarm_info, internal_time);
 228
 229         if (result < 0) {
 230                 alarmmgr_free_alarm(alarm_info);
 231                 return convert_error_code_to_alarm(__FUNCTION__, result);
 232         }
 233
 234
 235         if (period_in_second > 0)
 236                 result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_REPEAT, period_in_second);
 237         else
 238                 result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_ONCE, period_in_second);
 239
 240         if (result < 0) {
 241                 alarmmgr_free_alarm(alarm_info);
 242                 return convert_error_code_to_alarm(__FUNCTION__, result);
 243         }
 244
 245         result = alarmmgr_set_type(alarm_info, ALARM_TYPE_DEFAULT);
 246         if (result < 0) {
 247                 alarmmgr_free_alarm(alarm_info);
 248                 return convert_error_code_to_alarm(__FUNCTION__, result);
 249         }
 250
 251         result = alarmmgr_add_alarm_appsvc_with_localtime(alarm_info, bundle_data, alarm_id);
 252         if (result < 0) {
 253                 alarmmgr_free_alarm(alarm_info);
 254                 return convert_error_code_to_alarm(__FUNCTION__, result);
 255         }
 256
 257         alarmmgr_free_alarm(alarm_info);
 258         return ALARM_ERROR_NONE;
 259 }
 260
 261 int alarm_schedule_once_after_delay(app_control_h app_control, int delay, int *alarm_id)
 262 {
 263         bundle *bundle_data;
 264         int result = 0;
 265
 266         if (app_control == NULL) {
 267                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 268                 return ALARM_ERROR_INVALID_PARAMETER;
 269         }
 270
 271         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE) {
 272                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 273                 return ALARM_ERROR_INVALID_PARAMETER;
 274         }
 275
 276         result = alarmmgr_add_alarm_appsvc(ALARM_TYPE_DEFAULT, delay, 0, bundle_data, alarm_id);
 277
 278         return  convert_error_code_to_alarm(__FUNCTION__, result);
 279 }
 280
 281 int alarm_schedule_noti_once_after_delay(notification_h noti, int delay, int *alarm_id)
 282 {
 283         int result;
 284
 285         if (noti == NULL) {
 286                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 287                 return ALARM_ERROR_INVALID_PARAMETER;
 288         }
 289
 290         result = alarmmgr_add_alarm_noti(ALARM_TYPE_DEFAULT, delay, 0, noti, alarm_id);
 291
 292         return  convert_error_code_to_alarm(__FUNCTION__, result);
 293 }
 294
 295 int alarm_schedule_once_at_date(app_control_h app_control, struct tm *date, int *alarm_id)
 296 {
 297         alarm_date_t internal_time;
 298         alarm_entry_t *alarm_info;
 299         bundle *bundle_data;
 300         int result;
 301
 302         if (app_control == NULL || date == NULL) {
 303                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 304                 return ALARM_ERROR_INVALID_PARAMETER;
 305         }
 306
 307         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE) {
 308                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 309                 return ALARM_ERROR_INVALID_PARAMETER;
 310         }
 311
 312         alarm_info = alarmmgr_create_alarm();
 313         if (alarm_info == NULL) {
 314                 /* LCOV_EXCL_START */
 315                 LOGE("OUT_OF_MEMORY(0x%08x)", ALARM_ERROR_OUT_OF_MEMORY);
 316                 return ALARM_ERROR_OUT_OF_MEMORY;
 317                 /* LCOV_EXCL_STOP */
 318         }
 319
 320         internal_time.year = date->tm_year + 1900;
 321         internal_time.month = date->tm_mon + 1;
 322         internal_time.day = date->tm_mday;
 323
 324         internal_time.hour = date->tm_hour;
 325         internal_time.min = date->tm_min;
 326         internal_time.sec = date->tm_sec;
 327
 328         result = alarmmgr_set_time(alarm_info, internal_time);
 329
 330         if (result < 0) {
 331                 alarmmgr_free_alarm(alarm_info);
 332                 return convert_error_code_to_alarm(__FUNCTION__, result);
 333         }
 334
 335         result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_ONCE, 0);
 336         if (result < 0) {
 337                 alarmmgr_free_alarm(alarm_info);
 338                 return convert_error_code_to_alarm(__FUNCTION__, result);
 339         }
 340
 341         result = alarmmgr_set_type(alarm_info, ALARM_TYPE_DEFAULT);
 342         if (result < 0) {
 343                 alarmmgr_free_alarm(alarm_info);
 344                 return convert_error_code_to_alarm(__FUNCTION__, result);
 345         }
 346
 347         result = alarmmgr_add_alarm_appsvc_with_localtime(alarm_info, bundle_data, alarm_id);
 348         if (result < 0) {
 349                 alarmmgr_free_alarm(alarm_info);
 350                 return convert_error_code_to_alarm(__FUNCTION__, result);
 351         }
 352
 353         alarmmgr_free_alarm(alarm_info);
 354         return ALARM_ERROR_NONE;
 355 }
 356
 357 int alarm_schedule_noti_once_at_date(notification_h noti, struct tm *date, int *alarm_id)
 358 {
 359         alarm_date_t internal_time;
 360         alarm_entry_t *alarm_info;
 361         int result;
 362
 363         if (noti == NULL || date == NULL) {
 364                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 365                 return ALARM_ERROR_INVALID_PARAMETER;
 366         }
 367
 368         alarm_info = alarmmgr_create_alarm();
 369         if (alarm_info == NULL) {
 370                 /* LCOV_EXCL_START */
 371                 LOGE("OUT_OF_MEMORY(0x%08x)", ALARM_ERROR_OUT_OF_MEMORY);
 372                 return ALARM_ERROR_OUT_OF_MEMORY;
 373                 /* LCOV_EXCL_STOP */
 374         }
 375
 376         internal_time.year = date->tm_year + 1900;
 377         internal_time.month = date->tm_mon + 1;
 378         internal_time.day = date->tm_mday;
 379
 380         internal_time.hour = date->tm_hour;
 381         internal_time.min = date->tm_min;
 382         internal_time.sec = date->tm_sec;
 383
 384         result = alarmmgr_set_time(alarm_info, internal_time);
 385         if (result < 0) {
 386                 alarmmgr_free_alarm(alarm_info);
 387                 return convert_error_code_to_alarm(__FUNCTION__, result);
 388         }
 389
 390         result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_ONCE, 0);
 391         if (result < 0) {
 392                 alarmmgr_free_alarm(alarm_info);
 393                 return convert_error_code_to_alarm(__FUNCTION__, result);
 394         }
 395
 396         result = alarmmgr_set_type(alarm_info, ALARM_TYPE_DEFAULT);
 397         if (result < 0) {
 398                 alarmmgr_free_alarm(alarm_info);
 399                 return convert_error_code_to_alarm(__FUNCTION__, result);
 400         }
 401
 402         result = alarmmgr_add_alarm_noti_with_localtime(alarm_info, noti, alarm_id);
 403         if (result < 0) {
 404                 alarmmgr_free_alarm(alarm_info);
 405                 return convert_error_code_to_alarm(__FUNCTION__, result);
 406         }
 407
 408         alarmmgr_free_alarm(alarm_info);
 409         return ALARM_ERROR_NONE;
 410 }
 411
 412 int alarm_cancel(int alarm_id)
 413 {
 414         int result;
 415
 416         result = alarmmgr_remove_alarm(alarm_id);
 417
 418         return convert_error_code_to_alarm(__FUNCTION__, result);
 419 }
 420
 421 int alarm_cancel_all()
 422 {
 423         int result;
 424
 425         result = alarmmgr_remove_all();
 426
 427         return convert_error_code_to_alarm(__FUNCTION__, result);
 428 }
 429
 430 int alarm_foreach_registered_alarm(alarm_registered_alarm_cb callback, void *user_data)
 431 {
 432         int result;
 433         bool foreach_break = false;
 434
 435         if (callback == NULL) {
 436                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 437                 return ALARM_ERROR_INVALID_PARAMETER;
 438         }
 439
 440         /* alarm_registered_alarm_cb_broker */
 441         alarm_foreach_item_cb_context foreach_cb_context = {
 442                 .cb = callback,
 443                 .user_data = user_data,
 444                 .foreach_break = &foreach_break
 445         };
 446
 447         result = alarmmgr_enum_alarm_ids(alarm_registered_alarm_cb_broker, &foreach_cb_context);
 448
 449         return convert_error_code_to_alarm(__FUNCTION__, result);
 450 }
 451
 452 int alarm_get_current_time(struct tm *date)
 453 {
 454         time_t now;
 455
 456         if (date == NULL) {
 457                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 458                 return ALARM_ERROR_INVALID_PARAMETER;
 459         }
 460
 461         time(&now);
 462         localtime_r(&now, date);
 463         return ALARM_ERROR_NONE;
 464 }
 465
 466 int alarm_schedule_with_recurrence_week_flag(app_control_h app_control, struct tm *date, int week_flag, int *alarm_id)
 467 {
 468         alarm_date_t internal_time;
 469         alarm_entry_t *alarm_info;
 470         bundle *bundle_data;
 471         int result;
 472
 473         if (app_control == NULL || date == NULL) {
 474                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 475                 return ALARM_ERROR_INVALID_PARAMETER;
 476         }
 477
 478         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE) {
 479                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 480                 return ALARM_ERROR_INVALID_PARAMETER;
 481         }
 482
 483         alarm_info = alarmmgr_create_alarm();
 484
 485         internal_time.year = date->tm_year + 1900;
 486         internal_time.month = date->tm_mon + 1;
 487         internal_time.day = date->tm_mday;
 488
 489         internal_time.hour = date->tm_hour;
 490         internal_time.min = date->tm_min;
 491         internal_time.sec = date->tm_sec;
 492
 493         result = alarmmgr_set_time(alarm_info, internal_time);
 494         if (result < 0) {
 495                 alarmmgr_free_alarm(alarm_info);
 496                 return convert_error_code_to_alarm(__FUNCTION__, result);
 497         }
 498
 499         if (week_flag > 0) {
 500                 result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_WEEKLY, week_flag);
 501                 if (result < 0) {
 502                         alarmmgr_free_alarm(alarm_info);
 503                         return convert_error_code_to_alarm(__FUNCTION__, result);
 504                 }
 505         }
 506
 507         result = alarmmgr_set_type(alarm_info, ALARM_TYPE_DEFAULT);
 508         if (result < 0) {
 509                 alarmmgr_free_alarm(alarm_info);
 510                 return convert_error_code_to_alarm(__FUNCTION__, result);
 511         }
 512
 513         result = alarmmgr_add_alarm_appsvc_with_localtime(alarm_info, bundle_data, alarm_id);
 514         alarmmgr_free_alarm(alarm_info);
 515
 516         return convert_error_code_to_alarm(__FUNCTION__, result);
 517 }
 518
 519 int alarm_schedule_noti_with_recurrence_week_flag(notification_h noti, struct tm *date, int week_flag, int *alarm_id)
 520 {
 521         alarm_date_t internal_time;
 522         alarm_entry_t *alarm_info;
 523         int result;
 524
 525         if (noti == NULL || date == NULL) {
 526                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 527                 return ALARM_ERROR_INVALID_PARAMETER;
 528         }
 529
 530         alarm_info = alarmmgr_create_alarm();
 531
 532         internal_time.year = date->tm_year + 1900;
 533         internal_time.month = date->tm_mon + 1;
 534         internal_time.day = date->tm_mday;
 535
 536         internal_time.hour = date->tm_hour;
 537         internal_time.min = date->tm_min;
 538         internal_time.sec = date->tm_sec;
 539
 540         result = alarmmgr_set_time(alarm_info, internal_time);
 541         if (result < 0) {
 542                 alarmmgr_free_alarm(alarm_info);
 543                 return convert_error_code_to_alarm(__FUNCTION__, result);
 544         }
 545
 546         if (week_flag > 0)
 547                 result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_WEEKLY, week_flag);
 548
 549         if (result < 0) {
 550                 alarmmgr_free_alarm(alarm_info);
 551                 return convert_error_code_to_alarm(__FUNCTION__, result);
 552         }
 553
 554         result = alarmmgr_set_type(alarm_info, ALARM_TYPE_DEFAULT);
 555         if (result < 0) {
 556                 alarmmgr_free_alarm(alarm_info);
 557                 return convert_error_code_to_alarm(__FUNCTION__, result);
 558         }
 559
 560         result = alarmmgr_add_alarm_noti_with_localtime(alarm_info, noti, alarm_id);
 561         alarmmgr_free_alarm(alarm_info);
 562
 563         return convert_error_code_to_alarm(__FUNCTION__, result);
 564 }
 565
 566 int alarm_get_scheduled_recurrence_week_flag(int alarm_id, int *week_flag)
 567 {
 568         alarm_error_t result;
 569         alarm_entry_t *entry = NULL;
 570         alarm_repeat_mode_t mode;
 571         int value;
 572
 573         if (week_flag == NULL) {
 574                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 575                 return ALARM_ERROR_INVALID_PARAMETER;
 576         }
 577
 578         entry = alarmmgr_create_alarm();
 579
 580         result = alarmmgr_get_info(alarm_id, entry);
 581         if (result != ALARMMGR_RESULT_SUCCESS) {
 582                 if (entry != NULL)
 583                         alarmmgr_free_alarm(entry);
 584
 585                 return convert_error_code_to_alarm(__FUNCTION__, result);
 586         }
 587
 588         result = alarmmgr_get_repeat_mode(entry, &mode, &value);
 589
 590         if (mode != ALARM_REPEAT_MODE_WEEKLY) {
 591                 if (entry != NULL)
 592                         alarmmgr_free_alarm(entry);
 593
 594                 return ALARM_ERROR_INVALID_PARAMETER;
 595         }
 596
 597         if (result != ALARMMGR_RESULT_SUCCESS) {
 598                 if (entry != NULL)
 599                         alarmmgr_free_alarm(entry);
 600
 601                 return convert_error_code_to_alarm(__FUNCTION__, result);
 602         }
 603
 604         alarmmgr_free_alarm(entry);
 605
 606         (*week_flag) = value;
 607
 608         return ALARM_ERROR_NONE;
 609 }
 610
 611 int alarm_get_app_control(int alarm_id, app_control_h *app_control)
 612 {
 613         bundle *b = NULL;
 614         int error_code = 0;
 615
 616         if (app_control == NULL)
 617                 return ALARM_ERROR_INVALID_PARAMETER;
 618
 619         b = alarmmgr_get_alarm_appsvc_info(alarm_id, &error_code);
 620         if (error_code != ALARMMGR_RESULT_SUCCESS)
 621                 return convert_error_code_to_alarm(__FUNCTION__, error_code);
 622
 623         if (b == NULL)
 624                 return ALARM_ERROR_INVALID_PARAMETER;
 625
 626         error_code = app_control_create_request(b, app_control);
 627         if (error_code != APP_CONTROL_ERROR_NONE) {
 628                 /* LCOV_EXCL_START */
 629                 bundle_free(b);
 630                 return ALARM_ERROR_OUT_OF_MEMORY;
 631                 /* LCOV_EXCL_STOP */
 632         }
 633
 634         bundle_free(b);
 635
 636         return ALARM_ERROR_NONE;
 637 }
 638
 639 int alarm_get_notification(int alarm_id, notification_h *noti)
 640 {
 641         int error_code = 0;
 642
 643         error_code = alarmmgr_get_alarm_noti_info(alarm_id, noti);
 644         if (error_code != ALARMMGR_RESULT_SUCCESS)
 645                 return convert_error_code_to_alarm(__FUNCTION__, error_code);
 646
 647         return ALARM_ERROR_NONE;
 648 }
 649
 650 int alarm_set_global(int alarm_id, bool global)
 651 {
 652         int ret;
 653
 654         ret = alarmmgr_set_global(alarm_id, global);
 655
 656         return convert_error_code_to_alarm(__FUNCTION__, ret);
 657 }
 658
 659 int alarm_get_global(int alarm_id, bool *global)
 660 {
 661         int ret;
 662
 663         ret = alarmmgr_get_global(alarm_id, global);
 664
 665         return convert_error_code_to_alarm(__FUNCTION__, ret);
 666 }
 667
 668 /* extension API */
 669 int alarm_schedule_service_once_after_delay(app_control_h app_control, int delay, int *alarm_id)
 670 {
 671         bundle *bundle_data;
 672         int result = 0;
 673
 674         if (app_control == NULL) {
 675                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 676                 return ALARM_ERROR_INVALID_PARAMETER;
 677         }
 678
 679         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE) {
 680                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 681                 return ALARM_ERROR_INVALID_PARAMETER;
 682         }
 683
 684         result = alarmmgr_add_alarm_appsvc(ALARM_TYPE_DEFAULT | ALARM_TYPE_EXACT_SERVICE_APP, delay, 0, bundle_data, alarm_id);
 685
 686         return  convert_error_code_to_alarm(__FUNCTION__, result);
 687 }
 688
 689 int alarm_schedule_service_once_at_date(app_control_h app_control, struct tm *date, int *alarm_id)
 690 {
 691         alarm_date_t internal_time;
 692         alarm_entry_t* alarm_info;
 693         bundle *bundle_data;
 694         int result;
 695
 696         if (app_control == NULL || date == NULL) {
 697                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 698                 return ALARM_ERROR_INVALID_PARAMETER;
 699         }
 700
 701         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE) {
 702                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 703                 return ALARM_ERROR_INVALID_PARAMETER;
 704         }
 705
 706         alarm_info = alarmmgr_create_alarm();
 707
 708         internal_time.year = date->tm_year + 1900;
 709         internal_time.month = date->tm_mon + 1;
 710         internal_time.day = date->tm_mday;
 711
 712         internal_time.hour = date->tm_hour;
 713         internal_time.min = date->tm_min;
 714         internal_time.sec = date->tm_sec;
 715
 716         result = alarmmgr_set_time(alarm_info, internal_time);
 717
 718         if (result < 0) {
 719                 alarmmgr_free_alarm(alarm_info);
 720                 return convert_error_code_to_alarm(__FUNCTION__, result);
 721         }
 722
 723         result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_ONCE, 0);
 724
 725         if (result < 0) {
 726                 alarmmgr_free_alarm(alarm_info);
 727                 return convert_error_code_to_alarm(__FUNCTION__, result);
 728         }
 729
 730         result = alarmmgr_set_type(alarm_info, ALARM_TYPE_DEFAULT | ALARM_TYPE_EXACT_SERVICE_APP);
 731
 732         if (result < 0) {
 733                 alarmmgr_free_alarm(alarm_info);
 734                 return convert_error_code_to_alarm(__FUNCTION__, result);
 735         }
 736
 737         result = alarmmgr_add_alarm_appsvc_with_localtime(alarm_info, bundle_data, alarm_id);
 738
 739         if (result < 0) {
 740                 alarmmgr_free_alarm(alarm_info);
 741                 return convert_error_code_to_alarm(__FUNCTION__, result);
 742         }
 743
 744         alarmmgr_free_alarm(alarm_info);
 745         return ALARM_ERROR_NONE;
 746 }
 747
 748 int alarm_update_delay(int alarm_id, int delay)
 749 {
 750         alarm_date_t internal_time;
 751         alarm_entry_t *alarm_info;
 752         int result;
 753         struct timeval current_time;
 754         struct tm date;
 755
 756         if (delay < 0 || alarm_id < 0) {
 757                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 758                 return ALARM_ERROR_INVALID_PARAMETER;
 759         }
 760
 761         gettimeofday(&current_time, NULL);
 762         if (current_time.tv_usec > 500 * 1000)
 763                 current_time.tv_sec += (delay + 1);
 764         else
 765                 current_time.tv_sec += delay;
 766
 767         localtime_r(&current_time.tv_sec, &date);
 768
 769         internal_time.year = date.tm_year + 1900;
 770         internal_time.month = date.tm_mon + 1;
 771         internal_time.day = date.tm_mday;
 772
 773         internal_time.hour = date.tm_hour;
 774         internal_time.min = date.tm_min;
 775         internal_time.sec = date.tm_sec;
 776
 777         alarm_info = alarmmgr_create_alarm();
 778         if (alarm_info == NULL) {
 779                 /* LCOV_EXCL_START */
 780                 LOGE("OUT_OF_MEMORY(0x%08x)", ALARM_ERROR_OUT_OF_MEMORY);
 781                 return ALARM_ERROR_OUT_OF_MEMORY;
 782                 /* LCOV_EXCL_STOP */
 783         }
 784
 785         result = alarmmgr_set_time(alarm_info, internal_time);
 786         if (result < 0) {
 787                 alarmmgr_free_alarm(alarm_info);
 788                 return convert_error_code_to_alarm(__FUNCTION__, result);
 789         }
 790
 791         result = alarmmgr_update_alarm(alarm_id, alarm_info,
 792                         ALARM_UPDATE_FLAG_TIME);
 793         alarmmgr_free_alarm(alarm_info);
 794
 795         return convert_error_code_to_alarm(__FUNCTION__, result);
 796 }
 797
 798 int alarm_update_date(int alarm_id, struct tm *date)
 799 {
 800         alarm_date_t internal_time;
 801         alarm_entry_t *alarm_info;
 802         int result;
 803
 804         if (date == NULL || alarm_id < 0) {
 805                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 806                 return ALARM_ERROR_INVALID_PARAMETER;
 807         }
 808
 809         alarm_info = alarmmgr_create_alarm();
 810         if (alarm_info == NULL) {
 811                 /* LCOV_EXCL_START */
 812                 LOGE("OUT_OF_MEMORY(0x%08x)", ALARM_ERROR_OUT_OF_MEMORY);
 813                 return ALARM_ERROR_OUT_OF_MEMORY;
 814                 /* LCOV_EXCL_STOP */
 815         }
 816
 817         internal_time.year = date->tm_year + 1900;
 818         internal_time.month = date->tm_mon + 1;
 819         internal_time.day = date->tm_mday;
 820
 821         internal_time.hour = date->tm_hour;
 822         internal_time.min = date->tm_min;
 823         internal_time.sec = date->tm_sec;
 824
 825         result = alarmmgr_set_time(alarm_info, internal_time);
 826         if (result < 0) {
 827                 alarmmgr_free_alarm(alarm_info);
 828                 return convert_error_code_to_alarm(__FUNCTION__, result);
 829         }
 830
 831         result = alarmmgr_update_alarm(alarm_id, alarm_info,
 832                         ALARM_UPDATE_FLAG_TIME);
 833         alarmmgr_free_alarm(alarm_info);
 834
 835         return convert_error_code_to_alarm(__FUNCTION__, result);
 836 }
 837
 838 int alarm_update_period(int alarm_id, int period)
 839 {
 840         alarm_entry_t *alarm_info;
 841         int result;
 842
 843         if (period < 0 || alarm_id < 0) {
 844                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 845                 return ALARM_ERROR_INVALID_PARAMETER;
 846         }
 847
 848         alarm_info = alarmmgr_create_alarm();
 849         if (alarm_info == NULL) {
 850                 /* LCOV_EXCL_START */
 851                 LOGE("OUT_OF_MEMORY(0x%08x)", ALARM_ERROR_OUT_OF_MEMORY);
 852                 return ALARM_ERROR_OUT_OF_MEMORY;
 853                 /* LCOV_EXCL_STOP */
 854         }
 855
 856         if (period == 0) {
 857                 result = alarmmgr_update_alarm(alarm_id, alarm_info,
 858                                 ALARM_UPDATE_FLAG_CLEAR_PERIOD);
 859                 alarmmgr_free_alarm(alarm_info);
 860                 return convert_error_code_to_alarm(__FUNCTION__, result);
 861         }
 862
 863         result = alarmmgr_set_repeat_mode(alarm_info,
 864                         ALARM_REPEAT_MODE_REPEAT, period);
 865         if (result < 0) {
 866                 alarmmgr_free_alarm(alarm_info);
 867                 return convert_error_code_to_alarm(__FUNCTION__, result);
 868         }
 869
 870         result = alarmmgr_update_alarm(alarm_id, alarm_info,
 871                         ALARM_UPDATE_FLAG_PERIOD);
 872         alarmmgr_free_alarm(alarm_info);
 873
 874         return convert_error_code_to_alarm(__FUNCTION__, result);
 875 }
 876
 877 int alarm_update_week_flag(int alarm_id, int week_flag)
 878 {
 879         alarm_entry_t *alarm_info;
 880         int result;
 881
 882         if (week_flag < 0 || alarm_id < 0) {
 883                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 884                 return ALARM_ERROR_INVALID_PARAMETER;
 885         }
 886
 887         alarm_info = alarmmgr_create_alarm();
 888         if (alarm_info == NULL) {
 889                 /* LCOV_EXCL_START */
 890                 LOGE("OUT_OF_MEMORY(0x%08x)", ALARM_ERROR_OUT_OF_MEMORY);
 891                 return ALARM_ERROR_OUT_OF_MEMORY;
 892                 /* LCOV_EXCL_STOP */
 893         }
 894
 895         if (week_flag == 0) {
 896                 result = alarmmgr_update_alarm(alarm_id, alarm_info,
 897                                 ALARM_UPDATE_FLAG_CLEAR_WEEK_FLAG);
 898                 alarmmgr_free_alarm(alarm_info);
 899                 return convert_error_code_to_alarm(__FUNCTION__, result);
 900         }
 901
 902         result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_WEEKLY, week_flag);
 903         if (result < 0) {
 904                 alarmmgr_free_alarm(alarm_info);
 905                 return convert_error_code_to_alarm(__FUNCTION__, result);
 906         }
 907
 908         result = alarmmgr_update_alarm(alarm_id, alarm_info,
 909                         ALARM_UPDATE_FLAG_WEEK);
 910         alarmmgr_free_alarm(alarm_info);
 911
 912         return convert_error_code_to_alarm(__FUNCTION__, result);
 913 }
 914
 915 int alarm_set_systime(int new_time)
 916 {
 917         int result;
 918
 919         result = alarmmgr_set_systime(new_time);
 920         if (result < 0)
 921                 return convert_error_code_to_alarm(__FUNCTION__, result);
 922
 923         return ALARM_ERROR_NONE;
 924 }
 925
 926 int alarm_set_systime_with_propagation_delay(struct timespec new_time, struct timespec req_time)
 927 {
 928         int result;
 929
 930         result = alarmmgr_set_systime_with_propagation_delay(new_time, req_time);
 931         if (result < 0)
 932                 return convert_error_code_to_alarm(__FUNCTION__, result);
 933
 934         return ALARM_ERROR_NONE;
 935 }
 936
 937 int alarm_set_timezone(char *tzpath_str)
 938 {
 939         int result;
 940
 941         result = alarmmgr_set_timezone(tzpath_str);
 942         if (result < 0)
 943                 return convert_error_code_to_alarm(__FUNCTION__, result);
 944
 945         return ALARM_ERROR_NONE;
 946 }