alarm-lib.c

   1 /*
   2  *  alarm-manager
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Venkatesha Sarpangala <sarpangala.v@samsung.com>, Jayoun Lee <airjany@samsung.com>,
   7  * Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23
  24
  25
  26 #include<stdio.h>
  27 #include<stdlib.h>
  28 #include<errno.h>
  29 #include <unistd.h>
  30 #include <sys/stat.h>
  31 #include<sys/types.h>
  32 #include<string.h>
  33 #include<dbus/dbus.h>
  34 #include<dbus/dbus-glib.h>
  35 #include<glib.h>
  36 #include <fcntl.h>
  37 #include <dbus/dbus-glib-lowlevel.h>
  38
  39 #include "alarm.h"
  40 #include "alarm-internal.h"
  41 #include "alarm-stub.h"
  42 #include <bundle.h>
  43 #include <appsvc.h>
  44
  45 #define MAX_KEY_SIZE 256
  46
  47 static alarm_context_t alarm_context = { NULL, NULL, NULL, NULL, -1 };
  48
  49 static bool b_initialized = false;
  50 static bool sub_initialized = false;
  51
  52 #define MAX_OBJECT_PATH_LEN 256
  53 #define DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT 0
  54
  55 static DBusHandlerResult __expire_alarm_filter(DBusConnection *connection,
  56                                                DBusMessage *message,
  57                                                void *user_data);
  58 static int __alarm_validate_date(alarm_date_t *date, int *error_code);
  59 static bool __alarm_validate_time(alarm_date_t *date, int *error_code);
  60 static int __sub_init(void);
  61 static int __alarmmgr_init_appsvc(void);
  62 bool alarm_power_off(int *error_code);
  63 int alarmmgr_check_next_duetime(void);
  64
  65
  66
  67 static DBusHandlerResult __expire_alarm_filter(DBusConnection *connection,
  68                                                DBusMessage *message,
  69                                                void *user_data)
  70 {
  71         if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL) {
  72                 const char *method_name = dbus_message_get_member(message);
  73                 /*"alarm_expired" */
  74
  75                 if (strcmp(method_name, "alarm_expired") == 0) {
  76                         DBusMessageIter iter;
  77                         alarm_id_t alarm_id;
  78                         const char *service_name =
  79                             dbus_message_get_destination(message);
  80                         const char *object_path =
  81                             dbus_message_get_path(message);
  82                         /* "/org/tizen/alarm/client" */
  83                         const char *interface_name =
  84                             dbus_message_get_interface(message);
  85                         /* "org.tizen.alarm.client" */
  86
  87                         dbus_message_iter_init(message, &iter);
  88                         dbus_message_iter_get_basic(&iter, &alarm_id);
  89
  90                         ALARM_MGR_LOG_PRINT("[alarm-lib]:service_name=%s, "
  91                         "object_path=%s, interface_name=%s, method_name=%s, "
  92                         "alarm_id=%d, handler=%s\n",
  93                         service_name ? service_name : "no name",
  94                         object_path ? object_path : "no path",
  95                         interface_name ? interface_name : "no interface",
  96                         method_name ? method_name : "no method", alarm_id,
  97                         alarm_context.alarm_handler ? "ok" : "no handler");
  98
  99                         if (alarm_context.alarm_handler != NULL)
 100                                 /* alarm_context.alarm_handler(alarm_id); */
 101                                 alarm_context.alarm_handler(alarm_id,
 102                                         alarm_context.user_param);
 103                         return DBUS_HANDLER_RESULT_HANDLED;
 104                 }
 105         }
 106
 107         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 108
 109 }
 110
 111 static int __alarm_validate_date(alarm_date_t *date, int *error_code)
 112 {
 113
 114         if (date->year == 0 && date->month == 0 && date->day == 0) {
 115                 return true;
 116         }
 117
 118         int year = date->year;
 119         int month = date->month;
 120         int day = date->day;
 121
 122         if (month < 1 || month > 12) {
 123                 if (error_code)
 124                         *error_code = ERR_ALARM_INVALID_DATE;
 125                 return false;
 126         }
 127
 128         if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8
 129              || month == 10 || month == 12)
 130             && (day < 1 || day > 31)) {
 131                 if (error_code)
 132                         *error_code = ERR_ALARM_INVALID_DATE;
 133                 return false;
 134         }
 135
 136         if ((month == 4 || month == 6 || month == 9 || month == 11)
 137             && (day < 1 || day > 30)) {
 138                 if (error_code)
 139                         *error_code = ERR_ALARM_INVALID_DATE;
 140                 return false;
 141         }
 142
 143         if (month == 2) {
 144                 if ((year % 100 != 0 && year % 4 == 0) || (year % 400 == 0)) {
 145                         if (day < 1 || day > 29) {
 146                                 if (error_code)
 147                                         *error_code = ERR_ALARM_INVALID_DATE;
 148                                 return false;
 149                         }
 150                 } else {
 151                         if (day < 1 || day > 28) {
 152                                 if (error_code)
 153                                         *error_code = ERR_ALARM_INVALID_DATE;
 154                                 return false;
 155                         }
 156                 }
 157
 158         }
 159
 160         return true;
 161
 162 }
 163
 164 static bool __alarm_validate_time(alarm_date_t *date, int *error_code)
 165 {
 166         if (date->hour < 0 || date->hour > 23) {
 167                 if (error_code)
 168                         *error_code = ERR_ALARM_INVALID_TIME;
 169                 return false;
 170         }
 171
 172         if (date->min < 0 || date->min > 59) {
 173                 if (error_code)
 174                         *error_code = ERR_ALARM_INVALID_TIME;
 175                 return false;
 176         }
 177
 178         return true;
 179 }
 180
 181 static int __sub_init()
 182 {
 183         GError *error = NULL;
 184
 185         if (sub_initialized) {
 186                 ALARM_MGR_EXCEPTION_PRINT("__sub_init was already called.\n");
 187                 return ALARMMGR_RESULT_SUCCESS;
 188         }
 189
 190         g_thread_init(NULL);
 191         dbus_g_thread_init();
 192
 193         alarm_context.bus = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
 194         if (alarm_context.bus == NULL) {
 195                 ALARM_MGR_EXCEPTION_PRINT("dbus bus get failed\n");
 196
 197                 return ERR_ALARM_SYSTEM_FAIL;
 198         }
 199
 200         alarm_context.proxy = dbus_g_proxy_new_for_name(alarm_context.bus,
 201                                                         "org.tizen.alarm.manager",
 202                                                         "/org/tizen/alarm/manager",
 203                                                         "org.tizen.alarm.manager");
 204         if (alarm_context.proxy == NULL) {
 205                 ALARM_MGR_EXCEPTION_PRINT("dbus bus proxy get failed\n");
 206
 207                 return ERR_ALARM_SYSTEM_FAIL;
 208         }
 209
 210         alarm_context.pid = getpid();   /*this running appliction's process id*/
 211
 212         sub_initialized = true;
 213
 214         return ALARMMGR_RESULT_SUCCESS;
 215 }
 216
 217 bool alarm_power_off(int *error_code)
 218 {
 219         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_power_off() is called\n");
 220
 221 #ifdef __ALARM_BOOT
 222         return _send_alarm_power_off(alarm_context, error_code);
 223 #else
 224         ALARM_MGR_LOG_PRINT(
 225                         "[alarm-lib]:ALARM_BOOT feature is not supported. "
 226                             "so we return false.\n");
 227         if (error_code)
 228                 *error_code = -1;       /*-1 means that system failed
 229                                                         internally.*/
 230         return false;
 231 #endif
 232 }
 233
 234 int alarmmgr_check_next_duetime()
 235 {
 236         int error_code;
 237         ALARM_MGR_LOG_PRINT(
 238             "[alarm-lib]:alarm_check_next_duetime() is called\n");
 239
 240 #ifdef __ALARM_BOOT
 241         if (!_send_alarm_check_next_duetime(alarm_context, &error_code))
 242                 return error_code;
 243 #else
 244         ALARM_MGR_LOG_PRINT(
 245                     "[alarm-lib]:ALARM_BOOT feature is not supported. "
 246                             "so we return false.\n");
 247         return ERR_ALARM_SYSTEM_FAIL;
 248 #endif
 249
 250         return ALARMMGR_RESULT_SUCCESS;
 251 }
 252
 253 EXPORT_API int alarmmgr_init(const char *appid)
 254 {
 255         DBusError derror;
 256         int request_name_result = 0;
 257         char service_name[MAX_SERVICE_NAME_LEN] = { 0 };
 258         char service_name_mod[MAX_SERVICE_NAME_LEN]= { 0 };
 259
 260         int ret;
 261         int i = 0;
 262         int j = 0;
 263
 264         if (appid == NULL)
 265                 return ERR_ALARM_INVALID_PARAM;
 266
 267         if (strlen(appid) >= MAX_PKG_NAME_LEN)
 268                 return ERR_ALARM_INVALID_PARAM;
 269
 270         if (b_initialized) {
 271                 ALARM_MGR_EXCEPTION_PRINT(
 272                      "alarm was already initialized. app_service_name=%s\n",
 273                      g_quark_to_string(alarm_context.quark_app_service_name));
 274                 return ALARMMGR_RESULT_SUCCESS;
 275         }
 276
 277         ret = __sub_init();
 278         if (ret < 0)
 279                 return ret;
 280
 281         memset(service_name_mod, 'a', MAX_SERVICE_NAME_LEN-1);
 282         strncpy(service_name, appid, MAX_PKG_NAME_LEN);
 283
 284         j=0;
 285
 286         for(i=0;i<=strlen(service_name);i++)
 287         {
 288                 if (service_name[i] == '.' )
 289                 {
 290                         service_name_mod[j] = service_name[i];
 291                         j++;
 292                 }
 293                 else{
 294                         service_name_mod[j] = service_name[i];
 295                 }
 296                 j++;
 297         }
 298
 299         strncat(service_name, ".ALARM", strlen(".ALARM"));
 300
 301         strncat(service_name_mod, ".ALARM", strlen(".ALARM"));
 302
 303
 304         dbus_error_init(&derror);
 305
 306         request_name_result = dbus_bus_request_name(
 307                           dbus_g_connection_get_connection(alarm_context.bus),
 308                           service_name_mod, 0, &derror);
 309         if (dbus_error_is_set(&derror)) /*failure*/ {
 310                 ALARM_MGR_EXCEPTION_PRINT(
 311                      "Failed to dbus_bus_request_name(%s): %s\n", service_name,
 312                      derror.message);
 313                 dbus_error_free(&derror);
 314
 315                 return ERR_ALARM_SYSTEM_FAIL;
 316         }
 317         alarm_context.quark_app_service_name =
 318             g_quark_from_string(service_name);
 319         alarm_context.quark_app_service_name_mod=
 320             g_quark_from_string(service_name_mod);
 321
 322
 323         if (!dbus_connection_add_filter(
 324              dbus_g_connection_get_connection(alarm_context.bus),
 325              __expire_alarm_filter, NULL, NULL)) {
 326                 ALARM_MGR_EXCEPTION_PRINT("add __expire_alarm_filter failed\n");
 327
 328                 return ERR_ALARM_SYSTEM_FAIL;
 329         }
 330
 331         b_initialized = true;
 332         return ALARMMGR_RESULT_SUCCESS;
 333
 334 }
 335
 336 EXPORT_API void alarmmgr_fini()
 337 {
 338         dbus_connection_remove_filter(dbus_g_connection_get_connection
 339                                       (alarm_context.bus),
 340                                       __expire_alarm_filter, NULL);
 341 }
 342
 343 EXPORT_API int alarmmgr_set_cb(alarm_cb_t handler, void *user_param)
 344 {
 345         ALARM_MGR_LOG_PRINT("alarm_set_cb is called\n");
 346
 347         if (handler == NULL) {
 348                 return ERR_ALARM_INVALID_PARAM;
 349         }
 350         alarm_context.alarm_handler = handler;
 351         alarm_context.user_param = user_param;
 352         return ALARMMGR_RESULT_SUCCESS;
 353 }
 354
 355 EXPORT_API alarm_entry_t *alarmmgr_create_alarm(void)
 356 {
 357         alarm_info_t *alarm = (alarm_info_t *) malloc(sizeof(alarm_info_t));
 358
 359         if (NULL == alarm)
 360         {
 361                 return NULL;
 362         }
 363
 364         alarm->start.year = 0;
 365         alarm->start.month = 0;
 366         alarm->start.day = 0;
 367         alarm->start.hour = 0;
 368         alarm->start.min = 0;
 369         alarm->start.sec = 0;
 370
 371         alarm->end.year = 0;
 372         alarm->end.month = 0;
 373         alarm->end.day = 0;
 374         alarm->end.hour = 0;
 375         alarm->end.min = 0;
 376         alarm->end.sec = 0;
 377
 378         alarm->mode.repeat = ALARM_REPEAT_MODE_ONCE;
 379         alarm->mode.u_interval.interval = 0;
 380
 381         alarm->alarm_type = ALARM_TYPE_DEFAULT;
 382
 383         alarm->reserved_info = 0;
 384
 385         return (alarm_entry_t *) alarm;
 386 }
 387
 388 EXPORT_API int alarmmgr_free_alarm(alarm_entry_t *alarm)
 389 {
 390         if (alarm == NULL) {
 391                 return ERR_ALARM_INVALID_PARAM;
 392         }
 393         free(alarm);
 394
 395         return ALARMMGR_RESULT_SUCCESS;
 396 }
 397
 398 EXPORT_API int alarmmgr_set_time(alarm_entry_t *alarm, alarm_date_t time)
 399 {
 400         alarm_info_t *alarm_info;       /*= (alarm_info_t*)alarm;*/
 401         int error_code;
 402
 403         if (alarm == NULL) {
 404                 return ERR_ALARM_INVALID_PARAM;
 405         }
 406
 407         alarm_info = (alarm_info_t *) alarm;
 408
 409         if (!__alarm_validate_date(&time, &error_code)) {
 410                 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
 411                 return error_code;
 412         }
 413
 414         if (!__alarm_validate_time(&time, &error_code)) {
 415                 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
 416                 return error_code;
 417         }
 418
 419         memcpy(&alarm_info->start, &time, sizeof(alarm_date_t));
 420
 421         return ALARMMGR_RESULT_SUCCESS;
 422 }
 423
 424 EXPORT_API int alarmmgr_get_time(const alarm_entry_t *alarm,
 425                                  alarm_date_t *time)
 426 {
 427         alarm_info_t *alarm_info = (alarm_info_t *) alarm;
 428
 429         if (alarm == NULL) {
 430                 return ERR_ALARM_INVALID_PARAM;
 431         }
 432
 433         if (time != NULL)
 434                 memcpy(time, &alarm_info->start, sizeof(alarm_date_t));
 435
 436         return ALARMMGR_RESULT_SUCCESS;
 437 }
 438
 439 EXPORT_API int alarmmgr_set_repeat_mode(alarm_entry_t *alarm,
 440                                         alarm_repeat_mode_t repeat,
 441                                         int interval)
 442 {
 443         alarm_info_t *alarm_info = (alarm_info_t *) alarm;
 444
 445         if (repeat >= ALARM_REPEAT_MODE_MAX) {
 446                 return ERR_ALARM_INVALID_PARAM;
 447         }
 448
 449         alarm_info->mode.repeat = repeat;
 450
 451         if (repeat == ALARM_REPEAT_MODE_REPEAT
 452             || repeat == ALARM_REPEAT_MODE_WEEKLY) {
 453                 alarm_info->mode.u_interval.interval = interval;
 454         }
 455
 456         return ALARMMGR_RESULT_SUCCESS;
 457 }
 458
 459 EXPORT_API int alarmmgr_get_repeat_mode(const alarm_entry_t *alarm,
 460                                         alarm_repeat_mode_t *repeat,
 461                                         int *interval)
 462 {
 463         alarm_info_t *alarm_info = (alarm_info_t *) alarm;
 464
 465         if (alarm == NULL) {
 466                 return ERR_ALARM_INVALID_PARAM;
 467         }
 468
 469         if (repeat != NULL)
 470                 *repeat = alarm_info->mode.repeat;
 471         if (interval != NULL)
 472                 *interval = alarm_info->mode.u_interval.interval;
 473
 474         return ALARMMGR_RESULT_SUCCESS;
 475 }
 476
 477 EXPORT_API int alarmmgr_set_type(alarm_entry_t *alarm, int alarm_type)
 478 {
 479         alarm_info_t *alarm_info;       /*= (alarm_info_t*)alarm;*/
 480
 481         if (alarm == NULL) {
 482                 return ERR_ALARM_INVALID_PARAM;
 483         }
 484
 485         alarm_info = (alarm_info_t *) alarm;
 486
 487         alarm_info->alarm_type = alarm_type;
 488         alarm_info->alarm_type &= (~ALARM_TYPE_RELATIVE);
 489
 490         return ALARMMGR_RESULT_SUCCESS;
 491 }
 492
 493 EXPORT_API int alarmmgr_get_type(const alarm_entry_t *alarm, int *alarm_type)
 494 {
 495         alarm_info_t *alarm_info = (alarm_info_t *) alarm;
 496
 497         if (alarm == NULL) {
 498                 return ERR_ALARM_INVALID_PARAM;
 499         }
 500
 501         if (alarm_type != NULL)
 502                 *alarm_type = alarm_info->alarm_type;
 503
 504         return ALARMMGR_RESULT_SUCCESS;
 505 }
 506
 507
 508 static int __alarmmgr_init_appsvc(void)
 509 {
 510         int ret;
 511
 512         if (b_initialized) {
 513                 ALARM_MGR_EXCEPTION_PRINT("alarm was already initialized\n");
 514                 return ALARMMGR_RESULT_SUCCESS;
 515         }
 516
 517         g_thread_init(NULL);
 518
 519         dbus_g_thread_init();
 520
 521         ret = __sub_init();
 522         if (ret < 0)
 523                 return ret;
 524
 525         b_initialized = true;
 526
 527         return ALARMMGR_RESULT_SUCCESS;
 528
 529 }
 530
 531 EXPORT_API void *alarmmgr_get_alarm_appsvc_info(alarm_id_t alarm_id, int *return_code){
 532
 533         int ret = 0;
 534
 535         ret = __sub_init();
 536         if (ret < 0){
 537                 if (return_code)
 538                         *return_code = ret;
 539                 return NULL;
 540         }
 541
 542         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_get_alarm_appsvc_info() is called\n");
 543
 544         if (alarm_id <= 0) {
 545                 if (return_code)
 546                         *return_code = ERR_ALARM_INVALID_ID;
 547                 return NULL;
 548         }
 549
 550         return _send_alarm_get_appsvc_info(alarm_context, alarm_id, return_code);
 551
 552 }
 553
 554 EXPORT_API int alarmmgr_set_rtc_time(alarm_date_t *time){
 555
 556         int ret = 0;
 557         int error_code = 0;
 558
 559         if (!time){
 560                 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter time\n");
 561                 return ERR_ALARM_INVALID_PARAM;
 562         }
 563
 564         ret = __sub_init();
 565         if (ret < 0){
 566                 return ret;
 567         }
 568
 569         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_set_rtc_time() is called\n");
 570
 571         if (!__alarm_validate_date(time, &error_code)) {
 572                 ALARM_MGR_EXCEPTION_PRINT("RTC date error\n");
 573                 return error_code;
 574         }
 575
 576         if (!__alarm_validate_time(time, &error_code)) {
 577                 ALARM_MGR_EXCEPTION_PRINT("RTC time error\n");
 578                 return error_code;
 579         }
 580
 581         time->year-=1900;
 582         time->month-=1;
 583
 584         if (!_send_alarm_set_rtc_time
 585                 (alarm_context, time, &error_code)){
 586                         return error_code;
 587         }
 588
 589         return ALARMMGR_RESULT_SUCCESS;
 590
 591 }
 592
 593 EXPORT_API int alarmmgr_add_alarm_appsvc_with_localtime(alarm_entry_t *alarm, void *bundle_data, alarm_id_t *alarm_id)
 594 {
 595         alarm_info_t *alarm_info = NULL;        /* = (alarm_info_t*)alarm; */
 596         const char *operation = NULL;
 597         int error_code = 0;
 598         char *appid = NULL;
 599
 600         bundle *b=(bundle *)bundle_data;
 601
 602         if (alarm == NULL) {
 603                 return ERR_ALARM_INVALID_PARAM;
 604         }
 605
 606         if (NULL == b)
 607         {
 608                 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle\n");
 609                 return ERR_ALARM_INVALID_PARAM;
 610         }
 611         operation = appsvc_get_operation(b);
 612
 613         if (NULL == operation)
 614         {
 615                 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle [appsvc operation not present]\n");
 616                 return ERR_ALARM_INVALID_PARAM;
 617         }
 618
 619         if (__alarmmgr_init_appsvc() < 0)
 620         {
 621                 ALARM_MGR_EXCEPTION_PRINT("Unable to initialize dbus!!!\n");
 622                 return ERR_ALARM_SYSTEM_FAIL;
 623         }
 624
 625         alarm_info = (alarm_info_t *) alarm;
 626
 627         appid = appsvc_get_appid(b);
 628
 629         if (NULL == appid && (alarm_info->alarm_type & ALARM_TYPE_NOLAUNCH) )
 630         {
 631                 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
 632                 return ERR_ALARM_INVALID_PARAM;
 633         }
 634
 635         if (alarm_info == NULL || alarm_id == NULL) {
 636                 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
 637                 return ERR_ALARM_INVALID_PARAM;
 638         }
 639         alarm_mode_t *mode = &alarm_info->mode;
 640
 641         ALARM_MGR_LOG_PRINT("alarm_info->start.year(%d), "
 642                             "alarm_info->start.month(%d), alarm_info->start.day(%d)",
 643                             alarm_info->start.year, alarm_info->start.month,
 644                             alarm_info->start.day);
 645
 646         /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
 647         if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
 648                 return ERR_ALARM_INVALID_PARAM;
 649         }
 650
 651         if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
 652                 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
 653                 return error_code;
 654         }
 655
 656         if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
 657                 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
 658                 return error_code;
 659         }
 660
 661         if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
 662                 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
 663                 return error_code;
 664         }
 665
 666
 667         if (!_send_alarm_create_appsvc
 668             (alarm_context, alarm_info, alarm_id, b,
 669              &error_code)) {
 670                 return error_code;
 671         }
 672
 673         return ALARMMGR_RESULT_SUCCESS;
 674 }
 675
 676
 677
 678
 679 EXPORT_API int alarmmgr_add_alarm_with_localtime(alarm_entry_t *alarm,
 680                                                  const char *destination,
 681                                                  alarm_id_t *alarm_id)
 682 {
 683         char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
 684         char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
 685         alarm_info_t *alarm_info;       /* = (alarm_info_t*)alarm; */
 686         int ret;
 687         int i = 0;
 688         int j = 0;
 689
 690         if (alarm == NULL) {
 691                 return ERR_ALARM_INVALID_PARAM;
 692         }
 693
 694         alarm_info = (alarm_info_t *) alarm;
 695         if (alarm_info == NULL || alarm_id == NULL) {
 696                 return ERR_ALARM_INVALID_PARAM;
 697         }
 698
 699         int error_code;
 700         alarm_mode_t *mode = &alarm_info->mode;
 701
 702         ret = __sub_init();
 703         if (ret < 0)
 704                 return ret;
 705
 706         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
 707
 708         ALARM_MGR_LOG_PRINT("alarm_info->start.year(%d), "
 709                             "alarm_info->start.month(%d), alarm_info->start.day(%d)",
 710                             alarm_info->start.year, alarm_info->start.month,
 711                             alarm_info->start.day);
 712
 713         /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
 714         if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
 715                 return ERR_ALARM_INVALID_PARAM;
 716         }
 717
 718         if (destination && strlen(destination) >= MAX_PKG_NAME_LEN){
 719                 ALARM_MGR_EXCEPTION_PRINT("[alarm-lib]: destination name is too long!\n");
 720                 return ERR_ALARM_INVALID_PARAM;
 721         }
 722
 723
 724         if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
 725                 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
 726                 return error_code;
 727         }
 728
 729         if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
 730                 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
 731                 return error_code;
 732         }
 733
 734         if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
 735                 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
 736                 return error_code;
 737         }
 738
 739         if (destination != NULL) {
 740                 memset(dst_service_name, 0,
 741                        strlen(destination) + strlen(".ALARM") + 2);
 742                 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "%s",
 743                          destination);
 744
 745                 memset(dst_service_name_mod,'a',MAX_SERVICE_NAME_LEN-1);
 746
 747                 j=0;
 748
 749                 for(i=0; i<=strlen(dst_service_name); i++)
 750                 {
 751                         if (dst_service_name[i] == '.' )
 752                         {
 753                                 dst_service_name_mod[j] = dst_service_name[i];
 754                                 j++;
 755                         }
 756                         else
 757                         {
 758                                 dst_service_name_mod[j] = dst_service_name[i];
 759                         }
 760                         j++;
 761                 }
 762
 763                 strncat(dst_service_name, ".ALARM", strlen(".ALARM"));
 764                 strncat(dst_service_name_mod, ".ALARM", strlen(".ALARM"));
 765
 766                 if (!_send_alarm_create
 767                     (alarm_context, alarm_info, alarm_id, dst_service_name, dst_service_name_mod,
 768                      &error_code)) {
 769                         return error_code;
 770                 }
 771         } else
 772             if (!_send_alarm_create
 773                 (alarm_context, alarm_info, alarm_id, "null", "null", &error_code)) {
 774                 return error_code;
 775         }
 776
 777         return ALARMMGR_RESULT_SUCCESS;
 778 }
 779
 780
 781
 782 EXPORT_API int alarmmgr_add_alarm_appsvc(int alarm_type, time_t trigger_at_time,
 783                                   time_t interval, void *bundle_data,
 784                                   alarm_id_t *alarm_id)
 785 {
 786         int error_code = 0;;
 787         time_t current_time;
 788         struct tm duetime_tm;
 789         alarm_info_t alarm_info;
 790         const char *operation = NULL;
 791         char *appid = NULL;
 792
 793         bundle *b=(bundle *)bundle_data;
 794
 795         if (NULL == b)
 796         {
 797                 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle\n");
 798                 return ERR_ALARM_INVALID_PARAM;
 799         }
 800         operation = appsvc_get_operation(b);
 801
 802         if (NULL == operation)
 803         {
 804                 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle [appsvc operation not present]\n");
 805                 return ERR_ALARM_INVALID_PARAM;
 806         }
 807
 808         appid = appsvc_get_appid(b);
 809
 810         if (NULL == appid && (alarm_type & ALARM_TYPE_NOLAUNCH) )
 811         {
 812                 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
 813                 return ERR_ALARM_INVALID_PARAM;
 814         }
 815
 816         if (__alarmmgr_init_appsvc() < 0)
 817         {
 818                 ALARM_MGR_EXCEPTION_PRINT("Unable to initialize dbus!!!\n");
 819                 return ERR_ALARM_SYSTEM_FAIL;
 820         }
 821
 822         ALARM_MGR_LOG_PRINT("interval(%d)", interval);
 823
 824         if (alarm_id == NULL) {
 825                 return ERR_ALARM_INVALID_PARAM;
 826         }
 827
 828         if (trigger_at_time < 0) {
 829                 return ERR_ALARM_INVALID_PARAM;
 830         }
 831
 832         alarm_info.alarm_type = alarm_type;
 833         alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
 834
 835         time(&current_time);
 836
 837         current_time += trigger_at_time;
 838
 839         localtime_r(&current_time, &duetime_tm);
 840
 841         alarm_info.start.year = duetime_tm.tm_year + 1900;
 842         alarm_info.start.month = duetime_tm.tm_mon + 1;
 843         alarm_info.start.day = duetime_tm.tm_mday;
 844
 845         alarm_info.end.year = 0;
 846         alarm_info.end.month = 0;
 847         alarm_info.end.day = 0;
 848
 849         alarm_info.start.hour = duetime_tm.tm_hour;
 850         alarm_info.start.min = duetime_tm.tm_min;
 851         alarm_info.start.sec = duetime_tm.tm_sec;
 852
 853         if (interval <= 0) {
 854                 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
 855                 alarm_info.mode.u_interval.interval = 0;
 856         } else {
 857                 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
 858                 alarm_info.mode.u_interval.interval = interval;
 859         }
 860
 861         if (!_send_alarm_create_appsvc
 862             (alarm_context, &alarm_info, alarm_id, b,
 863              &error_code)) {
 864                 return error_code;
 865         }
 866
 867         return ALARMMGR_RESULT_SUCCESS;
 868 }
 869
 870
 871 EXPORT_API int alarmmgr_add_alarm(int alarm_type, time_t trigger_at_time,
 872                                   time_t interval, const char *destination,
 873                                   alarm_id_t *alarm_id)
 874 {
 875         char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
 876         char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
 877         int i = 0;
 878         int j = 0;
 879         int error_code;
 880         time_t current_time;
 881         struct tm duetime_tm;
 882         alarm_info_t alarm_info;
 883         int ret;
 884
 885         ret = __sub_init();
 886         if (ret < 0)
 887                 return ret;
 888
 889         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
 890
 891         ALARM_MGR_LOG_PRINT("interval(%d)", interval);
 892
 893         if (alarm_id == NULL) {
 894                 return ERR_ALARM_INVALID_PARAM;
 895         }
 896
 897         if (trigger_at_time < 0) {
 898                 return ERR_ALARM_INVALID_PARAM;
 899         }
 900
 901         if (destination && strlen(destination) >= MAX_PKG_NAME_LEN){
 902                 ALARM_MGR_EXCEPTION_PRINT("[alarm-lib]: destination name is too long!\n");
 903                 return ERR_ALARM_INVALID_PARAM;
 904         }
 905
 906         alarm_info.alarm_type = alarm_type;
 907         alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
 908
 909         time(&current_time);
 910
 911         current_time += trigger_at_time;
 912
 913         localtime_r(&current_time, &duetime_tm);
 914
 915         alarm_info.start.year = duetime_tm.tm_year + 1900;
 916         alarm_info.start.month = duetime_tm.tm_mon + 1;
 917         alarm_info.start.day = duetime_tm.tm_mday;
 918
 919         alarm_info.end.year = 0;
 920         alarm_info.end.month = 0;
 921         alarm_info.end.day = 0;
 922
 923         alarm_info.start.hour = duetime_tm.tm_hour;
 924         alarm_info.start.min = duetime_tm.tm_min;
 925         alarm_info.start.sec = duetime_tm.tm_sec;
 926
 927         if (interval <= 0) {
 928                 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
 929                 alarm_info.mode.u_interval.interval = 0;
 930         } else {
 931                 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
 932                 alarm_info.mode.u_interval.interval = interval;
 933         }
 934
 935         if (destination != NULL) {
 936                 memset(dst_service_name, 0,
 937                        strlen(destination) + strlen(".ALARM") + 2);
 938                 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "%s",
 939                          destination);
 940                 memset(dst_service_name_mod,'a',MAX_SERVICE_NAME_LEN-1);
 941
 942                 j=0;
 943
 944                 for(i=0;i<=strlen(dst_service_name);i++)
 945                 {
 946                         if (dst_service_name[i] == '.')
 947                         {
 948                                 dst_service_name_mod[j]=dst_service_name[i];
 949                                 j++;
 950                         }
 951                         else
 952                         {
 953                                 dst_service_name_mod[j]=dst_service_name[i];
 954                         }
 955                         j++;
 956                 }
 957
 958                 strncat(dst_service_name, ".ALARM", strlen(".ALARM"));
 959                 strncat(dst_service_name_mod, ".ALARM", strlen(".ALARM"));
 960
 961                 if (!_send_alarm_create
 962                     (alarm_context, &alarm_info, alarm_id, dst_service_name,dst_service_name_mod,
 963                      &error_code)) {
 964                         return error_code;
 965                 }
 966         } else
 967             if (!_send_alarm_create
 968                 (alarm_context, &alarm_info, alarm_id, "null","null", &error_code)) {
 969                 return error_code;
 970         }
 971
 972         return ALARMMGR_RESULT_SUCCESS;
 973 }
 974
 975 EXPORT_API int alarmmgr_remove_alarm(alarm_id_t alarm_id)
 976 {
 977         int error_code;
 978         int ret;
 979
 980         ret = __sub_init();
 981         if (ret < 0)
 982                 return ret;
 983
 984         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_delete() is called\n");
 985
 986         if (alarm_id <= 0) {
 987                 return ERR_ALARM_INVALID_ID;
 988         }
 989
 990         if (!_send_alarm_delete(alarm_context, alarm_id, &error_code))
 991                 return error_code;
 992
 993         return ALARMMGR_RESULT_SUCCESS;
 994 }
 995
 996 EXPORT_API int alarmmgr_enum_alarm_ids(alarm_enum_fn_t fn, void *user_param)
 997 {
 998         GError *error = NULL;
 999         GArray *alarm_array = NULL;
1000         int return_code = 0;
1001         int i = 0;
1002         int maxnum_of_ids;
1003         int num_of_ids;
1004         int alarm_id = -1;
1005         int ret;
1006
1007         if (fn == NULL)
1008                 return ERR_ALARM_INVALID_PARAM;
1009
1010         ret = __sub_init();
1011         if (ret < 0)
1012                 return ret;
1013
1014         if (!org_tizen_alarm_manager_alarm_get_number_of_ids(
1015             alarm_context.proxy, alarm_context.pid, &maxnum_of_ids,
1016                &return_code, &error)) {
1017                 /* dbus-glib error */
1018                 /* error_code should be set */
1019                 ALARM_MGR_EXCEPTION_PRINT(
1020                     "org_tizen_alarm_manager_alarm_get_number_of_ids() "
1021                     "failed. return_code[%d], return_code[%s]\n",
1022                 return_code, error->message);
1023         }
1024
1025         if (return_code != 0) {
1026                 return return_code;
1027         }
1028
1029         if (!org_tizen_alarm_manager_alarm_get_list_of_ids(
1030                      alarm_context.proxy, alarm_context.pid, maxnum_of_ids,
1031              &alarm_array, &num_of_ids, &return_code, &error)) {
1032                 /*dbus-glib error */
1033                 /* error_code should be set */
1034                 ALARM_MGR_EXCEPTION_PRINT(
1035                     "org_tizen_alarm_manager_alarm_get_list_of_ids() "
1036                     "failed. alarm_id[%d], return_code[%d]\n",
1037                      alarm_id, return_code);
1038         }
1039
1040         if (return_code != 0) {
1041                 return return_code;
1042         } else {
1043                 if (error != NULL) {
1044                         ALARM_MGR_LOG_PRINT(
1045                                 "Alarm server not ready dbus error message %s\n", error->message);
1046                         return ERR_ALARM_SYSTEM_FAIL;
1047                 }
1048                 if (NULL == alarm_array) {
1049                         ALARM_MGR_LOG_PRINT(
1050                                 "alarm server not initilized\n");
1051                         return ERR_ALARM_SYSTEM_FAIL;
1052                 }
1053                 for (i = 0; i < alarm_array->len && i < maxnum_of_ids; i++) {
1054                         alarm_id = g_array_index(alarm_array, alarm_id_t, i);
1055                         (*fn) (alarm_id, user_param);
1056                         ALARM_MGR_LOG_PRINT(" alarm_id(%d)\n", alarm_id);
1057                 }
1058
1059                 g_array_free(alarm_array, true);
1060         }
1061
1062         return ALARMMGR_RESULT_SUCCESS;
1063 }
1064
1065 EXPORT_API int alarmmgr_get_info(alarm_id_t alarm_id, alarm_entry_t *alarm)
1066 {
1067         int error_code;
1068         alarm_info_t *alarm_info = (alarm_info_t *) alarm;
1069
1070         int ret;
1071
1072         ret = __sub_init();
1073         if (ret < 0)
1074                 return ret;
1075
1076         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_get_info() is called\n");
1077
1078         if (alarm_id < 0 || alarm_info == NULL) {
1079                 return ERR_ALARM_INVALID_PARAM;
1080         }
1081
1082         if (!_send_alarm_get_info(alarm_context, alarm_id, alarm_info,
1083                                   &error_code))
1084                 return error_code;
1085
1086         return ALARMMGR_RESULT_SUCCESS;
1087 }
1088
1089 EXPORT_API int alarmmgr_power_on(bool on_off)
1090 {
1091         int error_code;
1092         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_power_on() is called\n");
1093
1094 #ifdef __ALARM_BOOT
1095         if (!_send_alarm_power_on(alarm_context, on_off, &error_code))
1096                 return error_code;
1097 #else
1098         ALARM_MGR_LOG_PRINT("[alarm-lib]:ALARM_BOOT feature is not supported. "
1099                             "so we return false.\n");
1100         return ERR_ALARM_SYSTEM_FAIL;
1101 #endif
1102
1103         return ALARMMGR_RESULT_SUCCESS;
1104 }
1105
1106 int alarmmgr_create(alarm_info_t *alarm_info, char *destination,
1107                     alarm_id_t *alarm_id)
1108 {
1109         char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
1110         alarm_mode_t *mode = &alarm_info->mode;
1111         int error_code;
1112
1113         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
1114
1115         if (alarm_info == NULL || alarm_id == NULL) {
1116                 return ERR_ALARM_INVALID_PARAM;
1117         }
1118
1119         ALARM_MGR_LOG_PRINT("alarm_info->start.year(%d), "
1120                             "alarm_info->start.month(%d), alarm_info->start.day(%d)",
1121                             alarm_info->start.year, alarm_info->start.month,
1122                             alarm_info->start.day);
1123
1124         /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
1125         if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
1126                 return ERR_ALARM_INVALID_PARAM;
1127         }
1128
1129         if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
1130                 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
1131                 return error_code;
1132         }
1133
1134         if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
1135                 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
1136                 return error_code;
1137         }
1138
1139         if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
1140                 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
1141                 return error_code;
1142         }
1143
1144         if (destination != NULL) {
1145                 memset(dst_service_name, 0,
1146                        strlen(destination) + strlen(".ALARM") + 2);
1147                 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "%s.ALARM",
1148                          destination);
1149                 if (!_send_alarm_create
1150                     (alarm_context, alarm_info, alarm_id, dst_service_name,"null",
1151                      &error_code)) {
1152                         return error_code;
1153                 }
1154         }
1155 /*TODO: Currently this API is not exported. Hence not modifying*/
1156         if (!_send_alarm_create
1157             (alarm_context, alarm_info, alarm_id, "null", "null", &error_code)) {
1158                 return error_code;
1159         }
1160
1161         return ALARMMGR_RESULT_SUCCESS;
1162
1163 }
1164
1165 int alarmmgr_get_number_of_ids(int *num_of_ids)
1166 {
1167         int error_code;
1168         ALARM_MGR_LOG_PRINT("[alarm-lib]:"
1169                             "alarm_get_number_of_ids() is called\n");
1170
1171         if (num_of_ids == NULL) {
1172                 return ERR_ALARM_INVALID_PARAM;
1173         }
1174         ALARM_MGR_LOG_PRINT("call alarm_get_number_of_ids\n");
1175         if (!_send_alarm_get_number_of_ids(alarm_context, num_of_ids,
1176                                            &error_code))
1177                 return error_code;
1178
1179         return ALARMMGR_RESULT_SUCCESS;
1180 }
1181
1182 int alarmmgr_get_list_of_ids(int maxnum_of_ids, alarm_id_t *alarm_id,
1183                              int *num_of_ids)
1184 {
1185         int error_code;
1186         ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_get_list_of_ids() is called\n");
1187
1188         if (maxnum_of_ids < 0 || alarm_id == NULL || num_of_ids == NULL) {
1189                 return ERR_ALARM_INVALID_PARAM;
1190         }
1191
1192         if (maxnum_of_ids == 0) {
1193                 *num_of_ids = 0;
1194                 return ALARMMGR_RESULT_SUCCESS;
1195         }
1196
1197         if (!_send_alarm_get_list_of_ids
1198             (alarm_context, maxnum_of_ids, alarm_id, num_of_ids, &error_code))
1199                 return error_code;
1200
1201         return ALARMMGR_RESULT_SUCCESS;
1202 }