email-core/email-core-alarm.c

   1 /*
   2 *  email-service
   3 *
   4 * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5 *
   6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>
   7 *
   8 * Licensed under the Apache License, Version 2.0 (the "License");
   9 * you may not use this file except in compliance with the License.
  10 * You may obtain a copy of the License at
  11 *
  12 * http://www.apache.org/licenses/LICENSE-2.0
  13 *
  14 * Unless required by applicable law or agreed to in writing, software
  15 * distributed under the License is distributed on an "AS IS" BASIS,
  16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 * See the License for the specific language governing permissions and
  18 * limitations under the License.
  19 *
  20 */
  21
  22
  23 /******************************************************************************
  24  * File :  email-core-alarm.c
  25  * Desc :  Alarm Management
  26  *
  27  * Auth :  Kyuho Jo
  28  *
  29  * History :
  30  *    2013.01.28  :  created
  31  *****************************************************************************/
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <time.h>
  36 #include <sys/types.h>
  37 #include <vconf.h>
  38 #include <glib.h>
  39 #include <alarm.h>
  40
  41 #include "email-convert.h"
  42 #include "email-types.h"
  43 #include "email-daemon.h"
  44 #include "email-debug-log.h"
  45 #include "email-storage.h"
  46 #include "email-network.h"
  47 #include "email-device.h"
  48 #include "email-utilities.h"
  49 #include "email-core-utils.h"
  50 #include "email-core-global.h"
  51 #include "email-core-alarm.h"
  52
  53
  54 INTERNAL_FUNC GList *alarm_data_list = NULL;
  55 static pthread_mutex_t alarm_data_lock = PTHREAD_MUTEX_INITIALIZER;
  56
  57 INTERNAL_FUNC int emcore_get_alarm_data_by_alarm_id(alarm_id_t input_alarm_id, email_alarm_data_t **output_alarm_data)
  58 {
  59         EM_DEBUG_FUNC_BEGIN("input_alarm_id [%d] output_alarm_data [%p]", input_alarm_id, output_alarm_data);
  60         int err = EMAIL_ERROR_NONE;
  61         GList *index = NULL;
  62         email_alarm_data_t *alarm_data = NULL;
  63
  64         if (output_alarm_data == NULL) {
  65                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
  66                 err = EMAIL_ERROR_INVALID_PARAM;
  67                 goto FINISH_OFF;
  68         }
  69
  70         ENTER_CRITICAL_SECTION(alarm_data_lock);
  71         index = g_list_first(alarm_data_list);
  72         while (index) {
  73                 alarm_data = index->data;
  74                 if (alarm_data->alarm_id == input_alarm_id) {
  75                         break;
  76                 }
  77                 index = g_list_next(index);
  78         }
  79         LEAVE_CRITICAL_SECTION(alarm_data_lock);
  80
  81         if (alarm_data)
  82                 *output_alarm_data = alarm_data;
  83         else
  84                 err = EMAIL_ERROR_ALARM_DATA_NOT_FOUND;
  85
  86 FINISH_OFF:
  87
  88         EM_DEBUG_FUNC_END("err [%d]", err);
  89         return err;
  90 }
  91
  92 INTERNAL_FUNC int emcore_get_alarm_data_by_reference_id(email_alarm_class_t input_class_id, int input_reference_id, email_alarm_data_t **output_alarm_data)
  93 {
  94         EM_DEBUG_FUNC_BEGIN("input_class_id [%d] input_reference_id [%d] output_alarm_data [%p]", input_class_id, input_reference_id, output_alarm_data);
  95         int err = EMAIL_ERROR_NONE;
  96         GList *index = NULL;
  97         email_alarm_data_t *alarm_data = NULL;
  98
  99         if (output_alarm_data == NULL) {
 100                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 101                 err = EMAIL_ERROR_INVALID_PARAM;
 102                 goto FINISH_OFF;
 103         }
 104
 105         ENTER_CRITICAL_SECTION(alarm_data_lock);
 106
 107         index = g_list_first(alarm_data_list);
 108
 109         while (index) {
 110                 alarm_data = index->data;
 111                 if (alarm_data->class_id == input_class_id && alarm_data->reference_id == input_reference_id) {
 112                         EM_DEBUG_LOG("found");
 113                         break;
 114                 }
 115                 index = g_list_next(index);
 116         }
 117
 118         LEAVE_CRITICAL_SECTION(alarm_data_lock);
 119
 120         if (index)
 121                 *output_alarm_data = alarm_data;
 122         else
 123                 err = EMAIL_ERROR_ALARM_DATA_NOT_FOUND;
 124
 125 FINISH_OFF:
 126
 127         EM_DEBUG_FUNC_END("err [%d]", err);
 128         return err;
 129 }
 130
 131 INTERNAL_FUNC int emcore_check_alarm_by_class_id(email_alarm_class_t input_class_id)
 132 {
 133         EM_DEBUG_FUNC_BEGIN("input_class_id [%d]", input_class_id);
 134         int err = EMAIL_ERROR_NONE;
 135         GList *index = NULL;
 136         email_alarm_data_t *alarm_data = NULL;
 137
 138         ENTER_CRITICAL_SECTION(alarm_data_lock);
 139         index = g_list_first(alarm_data_list);
 140         while (index) {
 141                 alarm_data = index->data;
 142                 if (alarm_data->class_id == input_class_id) {
 143                         EM_DEBUG_LOG("found");
 144                         break;
 145                 }
 146                 index = g_list_next(index);
 147         }
 148         LEAVE_CRITICAL_SECTION(alarm_data_lock);
 149
 150         if (!index)
 151                 err = EMAIL_ERROR_ALARM_DATA_NOT_FOUND;
 152
 153         EM_DEBUG_FUNC_END("err [%d]", err);
 154         return err;
 155 }
 156
 157 static int emcore_add_alarm_data_to_alarm_data_list(char *multi_user_name,
 158                                                                                                         alarm_id_t input_alarm_id,
 159                                                                                                         email_alarm_class_t input_class_id,
 160                                                                                                         int input_reference_id,
 161                                                                                                         time_t input_trigger_at_time,
 162                                                                                                         int (*input_alarm_callback)(email_alarm_data_t*, void *),
 163                                                                                                         void *user_data)
 164 {
 165         EM_DEBUG_FUNC_BEGIN("input_alarm_id [%d] input_class_id[%d] input_reference_id[%d] input_trigger_at_time[%d] input_alarm_callback [%p] user_data[%p]", input_alarm_id, input_class_id, input_reference_id, input_trigger_at_time, input_alarm_callback, user_data);
 166         int err = EMAIL_ERROR_NONE;
 167         email_alarm_data_t *alarm_data = NULL;
 168
 169         if (input_alarm_id == 0 || input_trigger_at_time == 0 || input_alarm_callback == NULL) {
 170                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 171                 err = EMAIL_ERROR_INVALID_PARAM;
 172                 goto FINISH_OFF;
 173         }
 174
 175         alarm_data = em_malloc(sizeof(email_alarm_data_t));
 176
 177         if (alarm_data == NULL) {
 178                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 179                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 180                 goto FINISH_OFF;
 181         }
 182
 183         alarm_data->alarm_id        = input_alarm_id;
 184         alarm_data->class_id        = input_class_id;
 185         alarm_data->reference_id    = input_reference_id;
 186         alarm_data->trigger_at_time = input_trigger_at_time;
 187         alarm_data->alarm_callback  = input_alarm_callback;
 188         alarm_data->user_data       = user_data;
 189         alarm_data->multi_user_name = EM_SAFE_STRDUP(multi_user_name);
 190
 191         ENTER_CRITICAL_SECTION(alarm_data_lock);
 192         alarm_data_list = g_list_append(alarm_data_list, (gpointer)alarm_data);
 193         LEAVE_CRITICAL_SECTION(alarm_data_lock);
 194
 195 FINISH_OFF:
 196
 197         EM_DEBUG_FUNC_END("err [%d]", err);
 198         return err;
 199 }
 200
 201 static int emcore_remove_alarm(email_alarm_data_t *input_alarm_data)
 202 {
 203         EM_DEBUG_FUNC_BEGIN("input_alarm_data [%p]", input_alarm_data);
 204
 205         int ret = ALARMMGR_RESULT_SUCCESS;
 206         int err = EMAIL_ERROR_NONE;
 207
 208         ENTER_CRITICAL_SECTION(alarm_data_lock);
 209         EM_DEBUG_LOG("alarm_id [%d]", input_alarm_data->alarm_id);
 210         if ((ret = alarmmgr_remove_alarm(input_alarm_data->alarm_id)) != ALARMMGR_RESULT_SUCCESS) {
 211                 EM_DEBUG_EXCEPTION("alarmmgr_remove_alarm failed [%d]", ret);
 212                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 213         }
 214         EM_SAFE_FREE(input_alarm_data->multi_user_name);
 215         LEAVE_CRITICAL_SECTION(alarm_data_lock);
 216
 217         EM_DEBUG_FUNC_END("err [%d]", err);
 218         return err;
 219 }
 220
 221 INTERNAL_FUNC int emcore_delete_alram_data_from_alarm_data_list(email_alarm_data_t *input_alarm_data)
 222 {
 223         EM_DEBUG_FUNC_BEGIN("input_alarm_data [%p]", input_alarm_data);
 224         int err = EMAIL_ERROR_NONE;
 225
 226         if (input_alarm_data == NULL) {
 227                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 228                 err = EMAIL_ERROR_INVALID_PARAM;
 229                 goto FINISH_OFF;
 230         }
 231
 232         if ((err = emcore_remove_alarm(input_alarm_data)) != EMAIL_ERROR_NONE) {
 233                 EM_DEBUG_EXCEPTION("emcore_remove_alarm failed [%d]", err);
 234         }
 235
 236         ENTER_CRITICAL_SECTION(alarm_data_lock);
 237         alarm_data_list = g_list_remove_all(alarm_data_list, input_alarm_data);
 238
 239         if (g_list_length(alarm_data_list) == 0) {
 240                 g_list_free(alarm_data_list);
 241                 alarm_data_list = NULL;
 242         }
 243         LEAVE_CRITICAL_SECTION(alarm_data_lock);
 244
 245 FINISH_OFF:
 246
 247         EM_DEBUG_FUNC_END("err [%d]", err);
 248         return err;
 249 }
 250
 251 INTERNAL_FUNC int emcore_delete_alram_data_by_reference_id(email_alarm_class_t input_class_id, int input_reference_id)
 252 {
 253         EM_DEBUG_FUNC_BEGIN("input_class_id[%d] input_reference_id[%d]", input_class_id, input_reference_id);
 254         int err = EMAIL_ERROR_NONE;
 255         email_alarm_data_t *alarm_data = NULL;
 256
 257         if ((err = emcore_get_alarm_data_by_reference_id(input_class_id, input_reference_id, &alarm_data)) != EMAIL_ERROR_NONE) {
 258                 EM_DEBUG_LOG("emcore_get_alarm_data_by_reference_id return [%d]", err);
 259                 goto FINISH_OFF;
 260         }
 261
 262         if ((err = emcore_delete_alram_data_from_alarm_data_list(alarm_data)) != EMAIL_ERROR_NONE) {
 263                 EM_DEBUG_LOG("emcore_delete_alram_data_from_alarm_data_list return [%d]", err);
 264         }
 265
 266 FINISH_OFF:
 267         EM_DEBUG_FUNC_END("err [%d]", err);
 268         return err;
 269 }
 270
 271 INTERNAL_FUNC int emcore_add_alarm(char *multi_user_name,
 272                                                                         time_t input_trigger_at_time,
 273                                                                         email_alarm_class_t input_class_id,
 274                                                                         int input_reference_id,
 275                                                                         int (*input_alarm_callback)(email_alarm_data_t*, void *),
 276                                                                         void *input_user_data)
 277 {
 278         EM_DEBUG_FUNC_BEGIN("input_trigger_at_time[%d] input_class_id[%d] input_reference_id[%d] "
 279                                                 "input_alarm_callback[%p] input_user_data[%p]",
 280                                                 input_trigger_at_time, input_class_id, input_reference_id,
 281                                                 input_alarm_callback, input_user_data);
 282
 283         int err = EMAIL_ERROR_NONE;
 284         int ret = 0;
 285         time_t alarm_interval = 0;
 286         time_t current_time = 0;
 287         alarm_id_t alarm_id = 0;
 288
 289         time(&current_time);
 290
 291         alarm_interval = input_trigger_at_time - current_time;
 292
 293         EM_DEBUG_ALARM_LOG("alarm_interval [%d]", (int)alarm_interval);
 294
 295         if ((ret = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE,
 296                                                                         alarm_interval,
 297                                                                         ALARM_REPEAT_MODE_ONCE,
 298                                                                         EMAIL_ALARM_DESTINATION,
 299                                                                         &alarm_id)) != ALARMMGR_RESULT_SUCCESS) {
 300                 EM_DEBUG_EXCEPTION("alarmmgr_add_alarm failed [%d]", ret);
 301                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 302                 goto FINISH_OFF;
 303         }
 304
 305         if ((err = emcore_add_alarm_data_to_alarm_data_list(multi_user_name,
 306                                                                                                                 alarm_id,
 307                                                                                                                 input_class_id,
 308                                                                                                                 input_reference_id,
 309                                                                                                                 input_trigger_at_time,
 310                                                                                                                 input_alarm_callback,
 311                                                                                                                 input_user_data)) != EMAIL_ERROR_NONE) {
 312                 EM_DEBUG_EXCEPTION("emcore_add_alarm_data_to_alarm_data_list failed [%d]", err);
 313                 goto FINISH_OFF;
 314         }
 315
 316 FINISH_OFF:
 317
 318         EM_DEBUG_FUNC_END("err [%d]", err);
 319         return err;
 320 }