alarm/alarm.c

   1 /*
   2  * Copyright (c) 2011 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 <time.h>
  19
  20 #include <alarm.h>
  21 #include <dlog.h>
  22
  23 #include <app_alarm.h>
  24 #include <app_control_internal.h>
  25
  26 #ifdef LOG_TAG
  27 #undef LOG_TAG
  28 #endif
  29
  30 #define LOG_TAG "CAPI_APPFW_ALARM"
  31
  32 typedef struct {
  33         alarm_registered_alarm_cb cb;
  34         void* user_data;
  35         bool* foreach_break;
  36 } alarm_foreach_item_cb_context;
  37
  38 static int alarm_registered_alarm_cb_broker(int alarm_id, void *user_data)
  39 {
  40         alarm_foreach_item_cb_context* foreach_cb_context = NULL;
  41
  42         if (user_data == NULL)
  43         {
  44                 return 0;
  45         }
  46
  47         foreach_cb_context = (alarm_foreach_item_cb_context*)user_data;
  48
  49         if (foreach_cb_context != NULL && *(foreach_cb_context->foreach_break) == false)
  50         {
  51                 if (foreach_cb_context->cb(alarm_id, foreach_cb_context->user_data) == false)
  52                 {
  53                         *(foreach_cb_context->foreach_break) = true;
  54                 }
  55         }
  56
  57         return 0;
  58 }
  59
  60 static int convert_error_code_to_alarm(const char* function, alarm_error_t alarm_error)
  61 {
  62         switch(alarm_error)
  63         {
  64         case ERR_ALARM_INVALID_PARAM:
  65         case ERR_ALARM_INVALID_REPEAT:
  66                 LOGE("[%s] INVALID_PARAMETER(0x%08x)", function, ALARM_ERROR_INVALID_PARAMETER);
  67                 return ALARM_ERROR_INVALID_PARAMETER;
  68                 break;
  69
  70         case ERR_ALARM_INVALID_ID:
  71                 LOGE("[%s] INVALID_PARAMETER(0x%08x)", function, ALARM_ERROR_INVALID_PARAMETER);
  72                 return ALARM_ERROR_INVALID_PARAMETER;
  73                 break;
  74
  75         case ERR_ALARM_INVALID_TIME:
  76                 LOGE("[%s] INVALID_TIME(0x%08x)", function, ALARM_ERROR_INVALID_TIME);
  77                 return ALARM_ERROR_INVALID_TIME;
  78                 break;
  79
  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
  85         case ERR_ALARM_NO_SERVICE_NAME:
  86                 LOGE("[%s] INVALID_PARAMETER(0x%08x)", function, ALARM_ERROR_INVALID_PARAMETER);
  87                 return ALARM_ERROR_INVALID_PARAMETER;
  88                 break;
  89
  90         case ERR_ALARM_SYSTEM_FAIL:
  91                 LOGE("[%s] CONNECTION_FAIL(0x%08x)", function, ALARM_ERROR_CONNECTION_FAIL);
  92                 return ALARM_ERROR_CONNECTION_FAIL;
  93                 break;
  94
  95         case ERR_ALARM_NO_PERMISSION:
  96                 LOGE("[%s] PERMISSION_DENIED(0x%08x)", function, ALARM_ERROR_PERMISSION_DENIED);
  97                 return ALARM_ERROR_PERMISSION_DENIED;
  98                 break;
  99
 100         case ALARMMGR_RESULT_SUCCESS:
 101                 return ALARM_ERROR_NONE;
 102                 break;
 103
 104         default:
 105                 return ALARM_ERROR_INVALID_PARAMETER;
 106         }
 107 }
 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         {
 116                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 117                 return ALARM_ERROR_INVALID_PARAMETER;
 118         }
 119
 120         result = alarmmgr_get_next_duetime(alarm_id, &due_time);
 121         if (result != ALARMMGR_RESULT_SUCCESS)
 122         {
 123                 return convert_error_code_to_alarm(__FUNCTION__, result);
 124         }
 125
 126         localtime_r(&due_time, date);
 127
 128         return ALARM_ERROR_NONE;
 129 }
 130
 131 int alarm_get_scheduled_period(int alarm_id, int* period)
 132 {
 133         alarm_error_t result;
 134         alarm_entry_t *entry = NULL;
 135         alarm_repeat_mode_t mode;
 136         int value;
 137
 138         if (period == NULL)
 139         {
 140                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 141                 return ALARM_ERROR_INVALID_PARAMETER;
 142         }
 143
 144         entry = alarmmgr_create_alarm();
 145
 146         result = alarmmgr_get_info(alarm_id, entry);
 147         if (result != ALARMMGR_RESULT_SUCCESS)
 148         {
 149                 if (entry != NULL)
 150                 {
 151                         alarmmgr_free_alarm(entry);
 152                 }
 153                 return convert_error_code_to_alarm(__FUNCTION__, result);
 154         }
 155
 156         result = alarmmgr_get_repeat_mode(entry, &mode, &value);
 157         if (result != ALARMMGR_RESULT_SUCCESS)
 158         {
 159                 if (entry != NULL)
 160                 {
 161                         alarmmgr_free_alarm(entry);
 162                 }
 163                 return convert_error_code_to_alarm(__FUNCTION__, result);
 164         }
 165
 166         result = alarmmgr_free_alarm(entry);
 167         if(result != ALARMMGR_RESULT_SUCCESS)
 168         {
 169                 if (entry != NULL)
 170                 {
 171                         alarmmgr_free_alarm(entry);
 172                 }
 173                 return convert_error_code_to_alarm(__FUNCTION__, result);
 174         }
 175
 176         (*period) = value;
 177
 178         return ALARM_ERROR_NONE;
 179 }
 180
 181 int alarm_schedule_after_delay(app_control_h app_control, int delay, int period, int *alarm_id)
 182 {
 183         bundle *bundle_data;
 184         int result = 0;
 185
 186         if (app_control == NULL)
 187         {
 188                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 189                 return ALARM_ERROR_INVALID_PARAMETER;
 190         }
 191
 192         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE)
 193         {
 194                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 195                 return ALARM_ERROR_INVALID_PARAMETER;
 196         }
 197
 198         result = alarmmgr_add_alarm_appsvc(ALARM_TYPE_DEFAULT, delay, period, bundle_data, alarm_id);
 199
 200         return  convert_error_code_to_alarm(__FUNCTION__, result);
 201 }
 202
 203 int alarm_schedule_at_date(app_control_h app_control, struct tm *date, int period_in_second, int *alarm_id)
 204 {
 205         alarm_date_t internal_time;
 206         alarm_entry_t* alarm_info;
 207         bundle *bundle_data;
 208         int result;
 209
 210         if (app_control == NULL || date == NULL)
 211         {
 212                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 213                 return ALARM_ERROR_INVALID_PARAMETER;
 214         }
 215
 216         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE)
 217         {
 218                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 219                 return ALARM_ERROR_INVALID_PARAMETER;
 220         }
 221
 222         alarm_info = alarmmgr_create_alarm();
 223
 224         internal_time.year = date->tm_year + 1900;
 225         internal_time.month = date->tm_mon +1;
 226         internal_time.day = date->tm_mday;
 227
 228         internal_time.hour = date->tm_hour;
 229         internal_time.min = date->tm_min;
 230         internal_time.sec = date->tm_sec;
 231
 232         result = alarmmgr_set_time(alarm_info,internal_time);
 233
 234         if (result < 0)
 235         {
 236                 alarmmgr_free_alarm(alarm_info);
 237                 return convert_error_code_to_alarm(__FUNCTION__, result);
 238         }
 239
 240         if (period_in_second > 0)
 241         {
 242                 result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_REPEAT, period_in_second);
 243         }
 244         else
 245         {
 246                 result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_ONCE, period_in_second);
 247         }
 248
 249         if (result < 0)
 250         {
 251                 alarmmgr_free_alarm(alarm_info);
 252                 return convert_error_code_to_alarm(__FUNCTION__, result);
 253         }
 254
 255         result = alarmmgr_set_type(alarm_info, ALARM_TYPE_DEFAULT);
 256
 257         if (result < 0)
 258         {
 259                 alarmmgr_free_alarm(alarm_info);
 260                 return convert_error_code_to_alarm(__FUNCTION__, result);
 261         }
 262
 263         result = alarmmgr_add_alarm_appsvc_with_localtime(alarm_info, bundle_data, alarm_id);
 264
 265         if (result < 0)
 266         {
 267                 alarmmgr_free_alarm(alarm_info);
 268                 return convert_error_code_to_alarm(__FUNCTION__, result);
 269         }
 270
 271         alarmmgr_free_alarm(alarm_info);
 272         return ALARM_ERROR_NONE;
 273 }
 274
 275 int alarm_cancel(int alarm_id)
 276 {
 277         int result;
 278
 279         result = alarmmgr_remove_alarm(alarm_id);
 280
 281         return convert_error_code_to_alarm(__FUNCTION__, result);
 282 }
 283
 284 int alarm_cancel_all()
 285 {
 286         LOGD("%s", __func__);
 287         int result = alarmmgr_remove_all();
 288         return convert_error_code_to_alarm(__FUNCTION__, result);
 289 }
 290
 291 int alarm_foreach_registered_alarm(alarm_registered_alarm_cb callback, void* user_data)
 292 {
 293         int result;
 294         bool foreach_break = false;
 295
 296         if (callback == NULL)
 297         {
 298                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 299                 return ALARM_ERROR_INVALID_PARAMETER;
 300         }
 301
 302         //alarm_registered_alarm_cb_broker
 303         alarm_foreach_item_cb_context foreach_cb_context = {
 304                 .cb = callback,
 305                 .user_data = user_data,
 306                 .foreach_break = &foreach_break
 307         };
 308
 309         result = alarmmgr_enum_alarm_ids(alarm_registered_alarm_cb_broker, &foreach_cb_context);
 310
 311         return convert_error_code_to_alarm(__FUNCTION__, result);
 312 }
 313
 314 int alarm_get_current_time(struct tm* date)
 315 {
 316         time_t now;
 317
 318         if (date == NULL)
 319         {
 320                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 321                 return ALARM_ERROR_INVALID_PARAMETER;
 322         }
 323
 324         time(&now);
 325         localtime_r(&now, date);
 326         return ALARM_ERROR_NONE;
 327 }
 328
 329
 330 int alarm_schedule_with_recurrence_week_flag(app_control_h app_control, struct tm *date, int week_flag,int *alarm_id)
 331 {
 332         alarm_date_t internal_time;
 333         alarm_entry_t* alarm_info;
 334         bundle *bundle_data;
 335         int result;
 336
 337         if (app_control == NULL || date == NULL)
 338         {
 339                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 340                 return ALARM_ERROR_INVALID_PARAMETER;
 341         }
 342
 343         if (app_control_to_bundle(app_control, &bundle_data) != APP_CONTROL_ERROR_NONE)
 344         {
 345                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 346                 return ALARM_ERROR_INVALID_PARAMETER;
 347         }
 348
 349         alarm_info = alarmmgr_create_alarm();
 350
 351         internal_time.year = date->tm_year + 1900;
 352         internal_time.month = date->tm_mon +1;
 353         internal_time.day = date->tm_mday;
 354
 355         internal_time.hour = date->tm_hour;
 356         internal_time.min = date->tm_min;
 357         internal_time.sec = date->tm_sec;
 358
 359         result = alarmmgr_set_time(alarm_info,internal_time);
 360
 361         if (result < 0)
 362         {
 363                 alarmmgr_free_alarm(alarm_info);
 364                 return convert_error_code_to_alarm(__FUNCTION__, result);
 365         }
 366
 367         if (week_flag > 0)
 368         {
 369                 result = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_WEEKLY, week_flag);
 370         }
 371
 372         if (result < 0)
 373         {
 374                 alarmmgr_free_alarm(alarm_info);
 375                 return convert_error_code_to_alarm(__FUNCTION__, result);
 376         }
 377
 378         result = alarmmgr_set_type(alarm_info, ALARM_TYPE_DEFAULT);
 379
 380         if (result < 0)
 381         {
 382                 alarmmgr_free_alarm(alarm_info);
 383                 return convert_error_code_to_alarm(__FUNCTION__, result);
 384         }
 385
 386         result = alarmmgr_add_alarm_appsvc_with_localtime(alarm_info, bundle_data, alarm_id);
 387
 388         alarmmgr_free_alarm(alarm_info);
 389         return convert_error_code_to_alarm(__FUNCTION__, result);
 390 }
 391
 392 int alarm_get_scheduled_recurrence_week_flag(int alarm_id, int *week_flag)
 393 {
 394         alarm_error_t result;
 395         alarm_entry_t *entry = NULL;
 396         alarm_repeat_mode_t mode;
 397         int value;
 398
 399         if(week_flag == NULL)
 400         {
 401                 LOGE("INVALID_PARAMETER(0x%08x)", ALARM_ERROR_INVALID_PARAMETER);
 402                 return ALARM_ERROR_INVALID_PARAMETER;
 403         }
 404
 405         entry = alarmmgr_create_alarm();
 406
 407         result = alarmmgr_get_info(alarm_id, entry);
 408         if(result != ALARMMGR_RESULT_SUCCESS)
 409         {
 410                 if (entry != NULL)
 411                 {
 412                         alarmmgr_free_alarm(entry);
 413                 }
 414                 return convert_error_code_to_alarm(__FUNCTION__, result);
 415         }
 416
 417         result = alarmmgr_get_repeat_mode(entry, &mode, &value);
 418
 419         if(mode != ALARM_REPEAT_MODE_WEEKLY)
 420         {
 421                 if (entry != NULL)
 422                 {
 423                         alarmmgr_free_alarm(entry);
 424                 }
 425                 return ALARM_ERROR_INVALID_PARAMETER;
 426         }
 427
 428         if(result != ALARMMGR_RESULT_SUCCESS)
 429         {
 430                 if (entry != NULL)
 431                 {
 432                         alarmmgr_free_alarm(entry);
 433                 }
 434                 return convert_error_code_to_alarm(__FUNCTION__, result);
 435         }
 436
 437         result = alarmmgr_free_alarm(entry);
 438         if(result != ALARMMGR_RESULT_SUCCESS)
 439         {
 440                 if (entry != NULL)
 441                 {
 442                         alarmmgr_free_alarm(entry);
 443                 }
 444                 return convert_error_code_to_alarm(__FUNCTION__, result);
 445         }
 446
 447         (*week_flag) = value;
 448
 449         return ALARM_ERROR_NONE;
 450 }
 451
 452 int alarm_get_app_control(int alarm_id, app_control_h *app_control)
 453 {
 454     bundle *b = NULL;
 455     int error_code = 0;
 456
 457     b = alarmmgr_get_alarm_appsvc_info(alarm_id, &error_code);
 458
 459     if(error_code != ALARMMGR_RESULT_SUCCESS)
 460     {
 461         return convert_error_code_to_alarm(__FUNCTION__, error_code);
 462     }
 463
 464     if(b == NULL)
 465     {
 466         return ALARM_ERROR_INVALID_PARAMETER;
 467     }
 468
 469     error_code = app_control_create_request(b, app_control);
 470
 471     if(error_code != APP_CONTROL_ERROR_NONE)
 472     {
 473         return ALARM_ERROR_OUT_OF_MEMORY;
 474     }
 475
 476     bundle_free(b);
 477
 478     return ALARM_ERROR_NONE;
 479 }
 480