src/wearable/hourly_alert.c

   1 /*
   2  * Copyright (c) 2000 - 2015 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 #include <Elementary.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22 #include <fcntl.h>
  23 #include <unistd.h>
  24 #include <string.h>
  25 #include <poll.h>
  26 #include <errno.h>
  27 #include <string.h>
  28
  29 #include <vconf.h>
  30 #include <signal.h>
  31 #include <app.h>
  32 #include <alarm.h>
  33 #include <feedback.h>
  34
  35 #include "util.h"
  36
  37
  38
  39 static struct {
  40         alarm_id_t alarm_id;    /* -1 : None, others : set alarm */
  41 } s_hourly_alert = {
  42         .alarm_id = -1,
  43 };
  44
  45
  46
  47 static int _alarm_delete_cb(alarm_id_t id, void *user_param)
  48 {
  49         int ret = ALARMMGR_RESULT_SUCCESS;
  50
  51         ret = alarmmgr_remove_alarm(id);
  52         if(ret != ALARMMGR_RESULT_SUCCESS) {
  53                 _E("alarmmgr_enum_alarm_ids() failed");
  54         }
  55
  56         return 0;
  57 }
  58
  59
  60
  61 static void _alarm_unset(void *data)
  62 {
  63         int ret = ALARMMGR_RESULT_SUCCESS;
  64
  65         if (s_hourly_alert.alarm_id != -1) {
  66                 _D("try to delete alarm_id(%d)", s_hourly_alert.alarm_id);
  67                 ret = alarmmgr_remove_alarm(s_hourly_alert.alarm_id);
  68                 if(ret != ALARMMGR_RESULT_SUCCESS) {
  69                         ret = alarmmgr_enum_alarm_ids(_alarm_delete_cb, NULL);
  70                         if(ret != ALARMMGR_RESULT_SUCCESS) {
  71                                 _E("alarmmgr_enum_alarm_ids() failed");
  72                         }
  73                 }
  74                 s_hourly_alert.alarm_id = -1;
  75         }
  76 }
  77
  78
  79
  80 static int _alarm_set(void *data)
  81 {
  82         int ret = ALARMMGR_RESULT_SUCCESS;
  83         time_t current_time;
  84         struct tm current_tm;
  85         alarm_entry_t *alarm_info = NULL;
  86         alarm_id_t alarm_id;
  87         alarm_date_t alarm_time;
  88
  89         /* delete before registering alarm ids */
  90         _alarm_unset(NULL);
  91
  92         time(&current_time);
  93
  94         /* alarm revision */
  95         current_time += 3600;   // +1 hour
  96
  97         localtime_r(&current_time, &current_tm);
  98
  99         alarm_info = alarmmgr_create_alarm();
 100         if(alarm_info == NULL) {
 101                 _E("alarmmgr_create_alarm() is failed\n");
 102                 return -1;
 103         }
 104
 105         alarm_time.year = current_tm.tm_year;
 106         alarm_time.month = current_tm.tm_mon;
 107         alarm_time.day = current_tm.tm_mday;
 108         alarm_time.hour = current_tm.tm_hour;
 109         alarm_time.min = 0;
 110         alarm_time.sec = 0;
 111
 112         //alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_ONCE, 0);
 113         ret = alarmmgr_set_repeat_mode(alarm_info, ALARM_REPEAT_MODE_REPEAT, 60*60);
 114         if(ret != ALARMMGR_RESULT_SUCCESS) {
 115                 _E("alarmmgr_set_repeat_mode() failed");
 116                 alarmmgr_free_alarm(alarm_info) ;
 117                 return -1;
 118         }
 119         alarmmgr_set_time(alarm_info, alarm_time);
 120         alarmmgr_set_type(alarm_info, ALARM_TYPE_VOLATILE);
 121
 122         ret = alarmmgr_add_alarm_with_localtime(alarm_info, NULL, &alarm_id);
 123         if(ret != ALARMMGR_RESULT_SUCCESS) {
 124                 _E("alarmmgr_add_alarm_with_localtime() failed");
 125                 alarmmgr_free_alarm(alarm_info) ;
 126                 return -1;
 127         }
 128
 129         s_hourly_alert.alarm_id = alarm_id;
 130         alarmmgr_free_alarm(alarm_info);
 131
 132         return 0;
 133 }
 134
 135
 136
 137 static int _alarm_cb(alarm_id_t alarm_id, void *data)
 138 {
 139         _D("hourly_alert alarm callback called");
 140
 141         feedback_initialize();
 142         feedback_play(FEEDBACK_PATTERN_NONE);
 143         feedback_deinitialize();
 144
 145         return 0;
 146 }
 147
 148
 149
 150 static int _alarm_init(void *data)
 151 {
 152         int ret = 0;
 153
 154         ret = alarmmgr_init("starter");
 155         retv_if(ret<0, -1);
 156
 157         ret = alarmmgr_set_cb(_alarm_cb, NULL);
 158         retv_if(ret<0, -1);
 159
 160         s_hourly_alert.alarm_id = -1;
 161
 162         return 0;
 163 }
 164
 165 static void _alarm_fini(void *data)
 166 {
 167         _alarm_unset(NULL);
 168         alarmmgr_fini();
 169 }
 170
 171
 172
 173 static Eina_Bool _register_hourly_alert_alarm(void)
 174 {
 175         int ret = 0;
 176
 177         ret = _alarm_init(NULL);
 178         retv_if(ret < 0, EINA_FALSE);
 179
 180         _alarm_set(NULL);
 181
 182         return EINA_TRUE;
 183
 184 }
 185
 186
 187
 188 static int _unregister_hourly_alert_alarm(void)
 189 {
 190         _alarm_fini(NULL);
 191         return 0;
 192 }
 193
 194
 195
 196 static void _hourly_alert_changed_cb(keynode_t* node, void *data)
 197 {
 198         int hourly_alert = -1;
 199
 200         _D("%s, %d", __func__, __LINE__);
 201
 202         if (node) {
 203                 hourly_alert = vconf_keynode_get_bool(node);
 204         } else {
 205                 if (vconf_get_int(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, &hourly_alert) < 0) {
 206                         _E("Failed to get %s", VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL);
 207                         return;
 208                 }
 209         }
 210
 211         if (hourly_alert == 1) {
 212                 _E("hourly_alert is set");
 213                 _register_hourly_alert_alarm();
 214         } else {
 215                 _E("hourly_alert is unset");
 216                 _unregister_hourly_alert_alarm();
 217         }
 218
 219 }
 220
 221
 222
 223 static void _hourly_system_time_changed_cb(keynode_t *node, void *data)
 224 {
 225         _alarm_set(NULL);
 226 }
 227
 228
 229
 230 void hourly_alert_init(void)
 231 {
 232         int hourly_alert = -1;
 233         int ret = 0;
 234
 235         ret = vconf_get_bool(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, &hourly_alert);
 236         if (ret < 0){
 237                 _E("can't get vconfkey value of [%s], ret=[%d]", VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, ret);
 238                 hourly_alert = 0;
 239         } else if (hourly_alert == 1) {
 240                 _D("[%s] value is [%d], hourly_alert is set..!!", VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, hourly_alert);
 241                 if (_register_hourly_alert_alarm() == EINA_FALSE) {
 242                         _E("_register_hourly_alert_alarm is failed..!!");
 243                 }
 244         }
 245
 246         if (vconf_notify_key_changed(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, _hourly_alert_changed_cb, NULL) < 0) {
 247                 _E("Failed to add the callback for %s changed", VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL);
 248         }
 249         /* for time revision */
 250         if (vconf_notify_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, _hourly_system_time_changed_cb, NULL) < 0) {
 251                 _E("Failed to add the callback for %s changed", VCONFKEY_SYSTEM_TIME_CHANGED);
 252         }
 253 }
 254
 255
 256
 257 void hourly_alert_fini(void)
 258 {
 259         _unregister_hourly_alert_alarm();
 260
 261         if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, _hourly_alert_changed_cb) < 0) {
 262                 _E("Failed to ignore the callback for %s changed", VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL);
 263         }
 264
 265         if (vconf_ignore_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, _hourly_system_time_changed_cb) < 0) {
 266                 _E("Failed to ignore the callback for %s changed", VCONFKEY_SYSTEM_TIME_CHANGED);
 267         }
 268 }
 269
 270
 271